„Stebuklinga lempa“ su Arduino

// ***************************** ******************************************** ********** //
# įtraukti
# įtraukti

#define blank_pin 3 // Apibūdina faktinį „PortD“ BIT „BIT“ - yra „Arduino UNO 3 kaištis“
#define latch_pin 2 // Nustatomas tikras PortD BIT užraktas - yra Arduino UNO 2 kaištis
#define clock_pin 13 // naudojama SPI, turi būti 13 SCK 13 Arduino UNO
#define data_pin 11 // naudojama SPI, turi būti MOSI 11 PIN kodas Arduino UNO

#define ROW 4
#define 5 mygtukas
#define PIN 6
#define POTPIN 7

„Adafruit_NeoPixel“ juostelė = „Adafruit_NeoPixel“ (16, PIN, NEO_GRB + NEO_KHZ800);

// ****************************** ********************************************* ********** //

baitų raudona [4];
baitas žalias [4];
baitas mėlynas [4];

int BAM_Bit, BAM_Counter = 0;

// ******************************************** ************************************* **** ********** //
#define BAM_RESOLUTION 4
#define COLOR_WHEEL_LENGTH 256

uint8_t colourR [COLOR_WHEEL_LENGTH];
uint8_t colourG [COLOR_WHEEL_LENGTH];
uint8_t colourB [COLOR_WHEEL_LENGTH];
int16_t „ColPos“ = 0;
uint16_t colourPos;
uint8_t R, G, B;

#define myPI 3.14159265358979323846
#define myDPI 1.2732395
#define myDPI2 0.40528473

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

negaliojanti sąranka ()
{
strip.begin ();
strip.setBrightness (50);
strip.show (); // Inicijuokite visus pikselius į 'išjungtą'

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 (ROW, OUTPUT);
pinMode (BUTTON, INPUT_PULLUP);

SPI.begin ();
pertraukia ();

fill_colour_wheel ();
skaidrus ();
}

tuščia kilpa ()
{
buttonState = digitalRead (BUTTON);
 
  if (buttonState! = lastButtonState) {
    if (buttonState == HIGH) {
      buttonPushCounter ++;
    }
    dar {

    }
  }
  lastButtonState = buttonState;

  jungiklis (mygtukasPushCounter% 5)
  {
    0 atvejis:

      POT = žemėlapis (analoginis skaitymas (POTPIN), 0, 1023, 0, 255);
      if (POT & lt; (OLD_POT * 0,95) || POT & gt; (OLD_POT * 1,05))
        {
          OLD_POT = POT; // išsaugoti pakeistą vertę
          „fillTable_colorwheelRGB“ (POT, R, G, B);
          vaivorykštė (POT);
        }

        pertrauka;
    1 atvejis:

      POT = žemėlapis (analoginis skaitymas (POTPIN), 0, 1023, 0, 255);
      if (POT & lt; (OLD_POT * 0,95) || POT & gt; (OLD_POT * 1,05))
        {
          OLD_POT = POT;
          gauti spalvos (POT, & R, & G, & B);
          „fillTable“ (R, G, B);
          užpildymas (POT);
        }

        pertrauka;

    2 atvejis:

      POT = žemėlapis (analoginis skaitymas (POTPIN), 0, 1023, 0, 255);
      if (POT & lt; (OLD_POT * 0,95) || POT & gt; (OLD_POT * 1,05))
        {
          OLD_POT = POT;
          gauti spalvos (POT, & R, & G, & B);
          „fillTable“ (R, G, B);
          fullWhite ();
        }

        pertrauka;
    3 atvejis:

      POT = žemėlapis (analoginis skaitymas (POTPIN), 0, 1023, 0, 255);
      if (POT & lt; (OLD_POT * 0,95) || POT & gt; (OLD_POT * 1,05))
        {
          OLD_POT = POT;
          „fillTable“ (0, 0, 0);
          vaivorykštė (POT);
        }

        pertrauka;
4 atvejis:
        skaidrus ();
        fullWhite ();
        pertrauka;
  }
}

tuščias šviesos diodas (int Y, int R, int G, int B)
{
  Y = suvaržymas (Y, 0, 7);
  
  R = suvaržymas (R, 0, 15);
  G = suvaržymas (G, 0, 15);
  B = suvaržymas (B, 0, 15);

  už (baitas BAM = 0; BAM & lt; BAM_RESOLUTION; BAM ++)
  {
    „bitWrite“ (raudona [BAM], Y, „bitRead“ (R, BAM));

    „bitWrite“ (žalia [BAM], Y, „bitRead“ (G, BAM));

    „bitWrite“ (mėlynas [BAM], Y, „bitRead“ (B, BAM));
  }
}

ISR (TIMER1_COMPA_vect) {
  
PORTD | = ((1 & my; myPI) {
    x - = 2 * myPI;
    g yra 1;
  }

  o (! g & (x & lt; -myPI)) {
    x + = 2 * myPI;
  }

  sinr = myDPI * x - myDPI2 * x * myAbs (x);
  sinr = 0,225 * (sinr * myAbs (sinr) -sinr) + sinr;

  grįžti sinr;
}

// GREITAS KOSINO PATVIRTINIMAS
„float myCos“ („float x“) {
  grąžinti „mySin“ (x + myPI / 2);
}

„float myTan“ („float x“) {
  grąžinti „mySin“ (x) / „myCos“ (x);
}

// ŠVEICARINĖS ŠAKNĖS PATVIRTINIMAS
„float mySqrt“ (plūduriuoja) {
  int16_t d = 0;
  int16_t in_ = in;
  plūdės rezultatas = 2;
  
  už (d = 0; in_> 0; in_ & gt; = 1) {
    d ++;
  }
  
  už (int16_t i = 0; i  0 (į) :-( į);
}

void fill_colour_wheel (negalioja)
{
  plūduriuoja raudona, žalia, mėlyna;
  plūdės c, s;
  int32_t fazė = 0;
  int16_t I = 0;

  kol (fazė & lt; COLOR_WHEEL_LENGTH)
  {
    s = (1 & lt; BAM_RESOLUTION) * mySin (myPI * (3 * fazė - I * COLOR_WHEEL_LENGTH) / (2 * COLOR_WHEEL_LENGTH));
    c = (1 & lt; BAM_RESOLUTION) * myCos (myPI * (3 * fazė - I * COLOR_WHEEL_LENGTH) / (2 * COLOR_WHEEL_LENGTH));

    raudona = (I == 0? 1: 0) * s + (I == 1? 1: 0) * c;
    žalia = (I == 1? 1: 0) * s + (I == 2? 1: 0) * c;
    mėlyna = (I == 2? 1: 0) * s + (I == 0? 1: 0) * c;

    colourR [fazė] = raudona;
    colourG [fazė] = žalia;
    colourB [fazė] = mėlyna;

    if (++ fazė & = = 1 + I) * COLOR_WHEEL_LENGTH / 3)
      I ++;
  }
}

negaliojantis spalvos gavimas (int16_t p, uint8_t * R, uint8_t * G, uint8_t * B)
{
  if (p & gt; = COLOR_WHEEL_LENGTH)
    p - = COLOR_WHEEL_LENGTH;

  * R = spalvaR [p];
  * G = spalvaG [p];
  * B = spalvaB [p];
}

negaliojantis gaukite kitą spalvą („uint8_t * R“, „uint8_t“ * G, „uint8_t * B“)
{
  if (++ „ColPos“ = COLOR_WHEEL_LENGTH)
    „ColPos“ - = COLOR_WHEEL_LENGTH;

  * R = spalvaR [ColPos];
  * G = spalvaG [ColPos];
  * B = spalvaB [ColPos];
}

negaliojančios spalvos padidėjimas_pastatas (uint8_t i)
{
  colourPos + = i;
  kol („colourPos & gt; = COLOR_WHEEL_LENGTH)
  {
    colourPos - = COLOR_WHEEL_LENGTH;
  }
}

// Įveskite reikšmę nuo 0 iki 255, kad gautumėte spalvos reikšmę.
// Spalvos yra perėjimas r - g - b - atgal į r.
uint32_t ratas (baitų „WheelPos“) {
  „WheelPos“ = 255 - „WheelPos“;
  if (WheelPos & lt; 85) {
    grąžinimo juostelė.Spalva (255 - „WheelPos * 3“, „0,„ WheelPos “* 3);
  }
  if (WheelPos & lt; 170) {
    „WheelPos“ - = 85;
    grąžinimo juostelė.Spalva (0, „WheelPos * 3“, 255 - „WheelPos“ * 3);
  }
  „WheelPos“ - = 170;
  grąžinimo juostelė.Spalva („WheelPos * 3“, „255“ - „WheelPos“ * 3, 0);
}