"מנורת קסם" עם ארדואינו

// ******************************************* .... ******************************************** .... ********** //
# כלול
# כלול

# הגדר blank_pin 3 // מגדיר BIT בפועל של PortD עבור ריק - הוא ארודינו UNO סיכה 3
#define latch_pin 2 // מגדיר את ה- BIT בפועל של PortD לתפס - הוא Arduino UNO סיכה 2
# הגדר שעון_פין 13 // בשימוש על ידי SPI, חייב להיות 13 SCK 13 ב- Arduino UNO
# הגדר את הנתונים_pin 11 // בשימוש על ידי SPI, חייב להיות סיכה MOSI 11 ב- Arduino UNO

# הגדר שורה 4
# הגדר את לחצן 5
# הגדר את מספר ה- PIN 6
# הגדר POTPIN 7

Adafruit_NeoPixel strip = Adafruit_NeoPixel (16, PIN, NEO_GRB + NEO_KHZ800);

// *************************************************** ******************************************** .... ********** //

אדום בתים [4];
ירוק בתים [4];
כחול בתים [4];

int BAM_Bit, BAM_Counter = 0;

// *************************************************** ******************************************** .... ********** //
# הגדר BAM_RESOLUTION 4
# הגדר COLOR_WHEEL_LENGTH 256

uint8_t צבע R [COLOR_WHEEL_LENGTH];
uint8_t צבעG [COLOR_WHEEL_LENGTH];
uint8_t צבע B [COLOR_WHEEL_LENGTH];
int16_t ColPos = 0;
uint16_t colourPos;
uint8_t R, G, B;

# הגדרת myPI 3.14159265358979323846
# הגדר את my DPI 1.2732395
# הגדר את myDPI2 0.40528473

int buttonPushCounter = 0;
int buttonState = 0;
int lastButtonState = 0;
int POT;
int OLD_POT;

הגדרת ביטול ()
{
strip.begin ();
strip.setBrightness (50);
strip.show (); // אתחל את כל הפיקסלים ל'כבה '

SPI.setBitOrder (MSBFIRST);
SPI.setDataMode (SPI_MODE0);
SPI.setClockDivider (SPI_CLOCK_DIV2);

noInterrupts ();

TCCR1A = B00000000;
TCCR1B = B00001011;
TIMSK1 = B00000010;
OCR1A = 8;

pinMode (latch_pin, OUTPUT);
pinMode (data_pin, OUTPUT);
pinMode (clock_pin, OUTPUT);

pinMode (שורה, תפוקה);
pinMode (BUTTON, INPUT_PULLUP);

SPI.begin ();
קוטע ();

fill_colour_wheel ();
ברור ();
}

לולאה חלילה ()
{
buttonState = digitalRead (BUTTON);
 
  if (buttonState! = lastButtonState) {
    אם (buttonState == HIGH) {
      buttonPushCounter ++;
    }
    אחרת {

    }
  }
  lastButtonState = buttonState;

  מתג (buttonPushCounter% 5)
  {
    מקרה 0:

      POT = מפה (analogRead (POTPIN), 0, 1023, 0, 255);
      אם (POT & lt; (OLD_POT * 0.95) || POT & gt; (OLD_POT * 1.05))
        {
          OLD_POT = POT; // שמור את הערך שהשתנה
          fillTable_colorwheelRGB (POT, R, G, B);
          קשת (POT);
        }

        שבירה;
    מקרה 1:

      POT = מפה (analogRead (POTPIN), 0, 1023, 0, 255);
      אם (POT & lt; (OLD_POT * 0.95) || POT & gt; (OLD_POT * 1.05))
        {
          OLD_POT = POT;
          get_colour (POT, & R, & G, & B);
          מילוי טבלה (R, G, B);
          מילוי (POT);
        }

        שבירה;

    מקרה 2:

      POT = מפה (analogRead (POTPIN), 0, 1023, 0, 255);
      אם (POT & lt; (OLD_POT * 0.95) || POT & gt; (OLD_POT * 1.05))
        {
          OLD_POT = POT;
          get_colour (POT, & R, & G, & B);
          מילוי טבלה (R, G, B);
          fullWhite ();
        }

        שבירה;
    מקרה 3:

      POT = מפה (analogRead (POTPIN), 0, 1023, 0, 255);
      אם (POT & lt; (OLD_POT * 0.95) || POT & gt; (OLD_POT * 1.05))
        {
          OLD_POT = POT;
          מילוי טבלה (0, 0, 0);
          קשת (POT);
        }

        שבירה;
מקרה 4:
        ברור ();
        fullWhite ();
        שבירה;
  }
}

LED חלל ריק (int Y, int R, int G, int B)
{
  Y = אילוץ (Y, 0, 7);
  
  R = אילוץ (R, 0, 15);
  G = אילוץ (G, 0, 15);
  B = אילוץ (B, 0, 15);

  עבור (בתים BAM = 0; BAM & lt; BAM_RESOLUTION; BAM ++)
  {
    bitWrite (אדום [BAM], Y, bitRead (R, BAM));

    bitWrite (ירוק [BAM], Y, bitRead (G, BAM));

    bitWrite (כחול [BAM], Y, bitRead (B, BAM));
  }
}

ISR (TIMER1_COMPA_vect) {
  
PORTD | = ((1 & lt; myPI) {
    x - = 2 * myPI;
    g הוא 1;
  }

  בעוד (! g & (x & lt; -myPI)) {
    x + = 2 * myPI;
  }

  sinr = myDPI * x - myDPI2 * x * myAbs (x);
  sinr = 0.225 * (sinr * myAbs (sinr) -sinr) + sinr;

  להחזיר סינר;
}

// יישום קוזין מהיר
צף myCos (צף x) {
  להחזיר את mySin (x + myPI / 2);
}

צף myTan (צף x) {
  להחזיר את mySin (x) / myCos (x);
}

// יישום שורש רבוע
צף mySqrt (צף פנימה) {
  int16_t d = 0;
  int16_t in_ = in;
  תוצאת ציפה = 2;
  
  עבור (d = 0; in_ & gt; 0; in_ & gt; & gt; = 1) {
    d ++;
  }
  
  עבור (int16_t i = 0; i & lt; d / 2; i ++) {
    תוצאה = תוצאה * 2;
  }
  
  עבור (int16_t i = 0; i & lt; 3; i ++) {
    תוצאה = 0.5 * (בתוצאה / תוצאה + תוצאה);
  }
  
  תוצאת החזרה;
}

// ערך מוחלט
צף myAbs (צף פנימה) {
  להחזיר (ב) & gt; 0? (ב) :-( בתוך);
}

void fill_colour_wheel (void)
{
  צף אדום, ירוק, כחול;
  לצוף c, s;
  int32_t שלב = 0;
  int16_t I = 0;

  בזמן (שלב & lt; COLOR_WHEEL_LENGTH)
  {
    s = (1 & lt; & lt; BAM_RESOLUTION) * mySin (myPI * (3 * שלב - אני * COLOR_WHEEL_LENGTH) / (2 * COLOR_WHEEL_LENGTH));
    c = (1 & lt; & lt; BAM_RESOLUTION) * myCos (myPI * (3 * שלב - אני * COLOR_WHEEL_LENGTH) / (2 * COLOR_WHEEL_LENGTH));

    אדום = (I == 0? 1: 0) * s + (I == 1? 1: 0) * c;
    ירוק = (I == 1? 1: 0) * s + (I == 2? 1: 0) * c;
    כחול = (I == 2? 1: 0) * s + (I == 0? 1: 0) * c;

    colourR [phase] = אדום;
    colourG [phase] = ירוק;
    colourB [phase] = כחול;

    אם (++ שלב & gt; = (1 + I) * COLOR_WHEEL_LENGTH / 3)
      אני ++;
  }
}

חלל get_colour (int16_t p, uint8_t * R, uint8_t * G, uint8_t * B)
{
  אם (p & gt; = COLOR_WHEEL_LENGTH)
    p - = COLOR_WHEEL_LENGTH;

  * R = צבע R [p];
  * G = צבעG [p];
  * B = צבע B [p];
}

בטל get_next_colour (uint8_t * R, uint8_t * G, uint8_t * B)
{
  אם (++ ColPos & gt; = COLOR_WHEEL_LENGTH)
    ColPos - = COLOR_WHEEL_LENGTH;

  * R = צבע R [ColPos];
  * G = צבעG [ColPos];
  * B = צבע B [ColPos];
}

חלל increment_colour_pos (uint8_t i)
{
  colourPos + = i;
  בעוד (colourPos & gt; = COLOR_WHEEL_LENGTH)
  {
    colourPos - = COLOR_WHEEL_LENGTH;
  }
}

// הזן ערך 0 עד 255 כדי לקבל ערך צבע.
// הצבעים הם מעבר r - g - b - חזרה ל- r.
uint32_t Wheel (בתים WheelPos) {
  WheelPos = 255 - WheelPos;
  אם (WheelPos & lt; 85) {
    רצועת החזרה. צבע (255 - WheelPos * 3, 0, WheelPos * 3);
  }
  אם (WheelPos & lt; 170) {
    גלגלים - = 85;
    רצועת החזרה. צבע (0, גלגל פוז * 3, 255 - גלגל פוס * 3);
  }
  גלגלים - = 170;
  רצועת החזרה. צבע (WheelPos * 3, 255 - WheelPos * 3, 0);
}