"Magická lampa" s Arduino

// ************************************************* * ************************************************** ** ********** //
#include
#include

#define blank_pin 3 // Definuje skutočný BIT PortD pre blank - je Arduino UNO pin 3
#define latch_pin 2 // Definuje skutočný BIT PortD pre západku - je Arduino UNO pin 2
#define clock_pin 13 //, ktorý používa SPI, musí byť na Arduino UNO 13 SCK 13
#define data_pin 11 // používaný SPI, musí byť pin MOSI 11 na Arduino UNO

#define ROW 4
#define TLAČIDLO 5
#define PIN 6
#define POTPIN 7

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

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

bajtová červená [4];
bajtová zelená [4];
bajtová modrá [4];

int BAM_Bit, BAM_Counter = 0;

// ******************************* .... ************************************************** ********** //
#definovať BAM_RESOLUTION 4
#definovať 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;
8, R, G, B;

#define myPI 3.14159265358979323846
#definovať myDPI 1.2732395
#definovať myDPI2 0,40528473

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

neplatné nastavenie ()
{
strip.egin ();
strip.setBrightness (50);
strip.show (); // Inicializácia všetkých pixlov na „vypnuté“

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

noInrupts ();

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 ();
prerušenia ();

fill_colour_wheel ();
clearfast ();
}

prázdna slučka ()
{
buttonState = digitalRead (BUTTON);
 
  if (buttonState! = lastButtonState) {
    if (buttonState == HIGH) {
      buttonPushCounter ++;
    }
    else {

    }
  }
  lastButtonState = buttonState;

  prepínač (buttonPushCounter% 5)
  {
    prípad 0:

      POT = mapa (analogRead (POTPIN), 0, 1023, 0, 255);
      if (POT <(OLD_POT * 0,95) || POT> (OLD_POT * 1,05))
        {
          OLD_POT = POT; // uložte zmenenú hodnotu
          fillTable_colorwheelRGB (POT, R, G, B);
          dúha (POT);
        }

        break;
    prípad 1:

      POT = mapa (analogRead (POTPIN), 0, 1023, 0, 255);
      if (POT <(OLD_POT * 0,95) || POT> (OLD_POT * 1,05))
        {
          OLD_POT = POT;
          get_colour (POT, & R, & G, & B);
          tabuľka výplní (R, G, B);
          výplň (POT);
        }

        break;

    prípad 2:

      POT = mapa (analogRead (POTPIN), 0, 1023, 0, 255);
      if (POT <(OLD_POT * 0,95) || POT> (OLD_POT * 1,05))
        {
          OLD_POT = POT;
          get_colour (POT, & R, & G, & B);
          tabuľka výplní (R, G, B);
          fullWhite ();
        }

        break;
    prípad 3:

      POT = mapa (analogRead (POTPIN), 0, 1023, 0, 255);
      if (POT <(OLD_POT * 0,95) || POT> (OLD_POT * 1,05))
        {
          OLD_POT = POT;
          fillTable (0, 0, 0);
          dúha (POT);
        }

        break;
prípad 4:
        clearfast ();
        fullWhite ();
        break;
  }
}

prázdna LED (int Y, int R, int G, int B)
{
  Y = obmedzenie (Y, 0, 7);
  
  R = väzba (R, 0, 15);
  G = väzba (G, 0, 15);
  B = obmedzenie (B, 0, 15);

  pre (bajt BAM = 0; BAM  0; in_>> = 1) {
    d ++;
  }
  
  pre (int16_t i = 0; i  0? (in) :-( in);
}

void fill_colour_wheel (void)
{
  plávajúca červená, zelená, modrá;
  float c, s;
  int32_t fáza = 0;
  int16_t I = 0;

  while (fáza > (1 + I) * COLOR_WHEEL_LENGTH / 3)
      I ++;
  }
}

void get_colour (int16_t p, uint8_t * R, uint8_t * G, uint8_t * B)
{
  ak (p & gt; = COLOR_WHEEL_LENGTH)
    p - = COLOR_WHEEL_LENGTH;

  * R = farbaR [p];
  * G = colorG [p];
  * B = farba B [p];
}

void get_next_colour (uint8_t * R, uint8_t * G, uint8_t * B)
{
  ak (++ ColPos> = COLOR_WHEEL_LENGTH)
    ColPos - = COLOR_WHEEL_LENGTH;

  * R = farbaR [ColPos];
  * G = colourG [ColPos];
  * B = farbivo B [ColPos];
}

void increment_colour_pos (uint8_t i)
{
  colourPos + = i;
  while (colourPos> = COLOR_WHEEL_LENGTH)
  {
    colourPos - = COLOR_WHEEL_LENGTH;
  }
}

// Ak chcete získať farebnú hodnotu, zadajte hodnotu 0 až 255.
// Farby sú prechodom r - g - b - späť do r.
uint32_t Wheel (byte WheelPos) {
  WheelPos = 255 - WheelPos;
  if (WheelPos <85) {
    spätný pás. Kolor (255 - WheelPos * 3, 0, WheelPos * 3);
  }
  if (WheelPos <170) {
    WheelPos - = 85;
    spätný pás. Kolor (0, WheelPos * 3, 255 - WheelPos * 3);
  }
  WheelPos - = 170;
  spätný pás.Color (WheelPos * 3, 255 - WheelPos * 3, 0);
}