"Čarobna svjetiljka" s Arduinom

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

#define blank_pin 3 // Definira stvarni BIT PortD za prazno - je Arduino UNO pin 3
#define latch_pin 2 // Definira stvarni BIT PortD za zasun - je li Arduino UNO pin 2
#define clock_pin 13 // koristi SPI, mora biti 13 SCK 13 na Arduino UNO
#define data_pin 11 // koristi SPI, mora biti pin MOSI 11 na Arduino UNO

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

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

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

bajt crvena [4];
bajt zelena [4];
bajt plava [4];

int BAM_Bit, BAM_Counter = 0;

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

uint8_t colorR [COLOR_WHEEL_LENGTH];
uint8_t colorG [COLOR_WHEEL_LENGTH];
uint8_t bojaB [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 buttonPushCounter = 0;
int buttonState = 0;
int lastButtonState = 0;
int POT;
int OLD_POT;

postavljanje praznine ()
{
strip.begin ();
strip.setBrightness (50);
strip.show (); // Inicijalizirajte sve piksele na 'isključeno'

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

nema prekida ();

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 ();
prekida ();

fill_colour_wheel ();
clearfast ();
}

void petlja ()
{
buttonState = digitalno čitanje (Gumb);
 
  ako (buttonState! = lastButtonState) {
    ako (buttonState == HIGH) {
      gumbPushCounter ++;
    }
    drugo {

    }
  }
  lastButtonState = buttonState;

  sklopka (gumbPushCounter% 5)
  {
    slučaj 0:

      POT = karta (analogRead (POTPIN), 0, 1023, 0, 255);
      if (POT <(OLD_POT * 0,95) || POT>> (OLD_POT * 1,05))
        {
          OLD_POT = POT; // spremite promijenjenu vrijednost
          fillTable_colorwheelRGB (POT, R, G, B);
          duga (POT);
        }

        razbiti;
    1. slučaj:

      POT = karta (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);
          fillTable (R, G, B);
          punjenje (POT);
        }

        razbiti;

    slučaj 2:

      POT = karta (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);
          fillTable (R, G, B);
          fullWhite ();
        }

        razbiti;
    3. slučaj:

      POT = karta (analogRead (POTPIN), 0, 1023, 0, 255);
      if (POT <(OLD_POT * 0,95) || POT>> (OLD_POT * 1,05))
        {
          OLD_POT = POT;
          fillTable (0, 0, 0);
          duga (POT);
        }

        razbiti;
slučaj 4:
        clearfast ();
        fullWhite ();
        razbiti;
  }
}

praznina LED (int Y, int R, int G, int B)
{
  Y = ograničenje (Y, 0, 7);
  
  R = ograničenje (R, 0, 15);
  G = ograničenje (G, 0, 15);
  B = ograničenje (B, 0, 15);

  za (bajt BAM = 0; BAM  0; in_>> = 1) {
    d ++;
  }
  
  za (int16_t i = 0; i & d / 2; i ++) {
    rezultat = rezultat * 2;
  }
  
  za (int16_t i = 0; i <3; i ++) {
    rezultat = 0,5 * (u / rezultat + rezultat);
  }
  
  povratni rezultat;
}

// APSOLUTNA VRIJEDNOST
plutajte myAbs (plutajte unutra) {
  povratak (in)> 0? (in) :-( in);
}

void fill_colour_wheel (praznina)
{
  plutaju crveno, zeleno, plavo;
  plutati c, s;
  int32_t faza = 0;
  int16_t I = 0;

  Dok (faza  gt (= 1 + I) * COLOR_WHEEL_LENGTH / 3)
      I ++;
  }
}

void get_colour (int16_t p, uint8_t * R, uint8_t * G, uint8_t * B)
{
  ako je (p> gt = COLOR_WHEEL_LENGTH)
    p - = COLOR_WHEEL_LENGTH;

  * R = bojaR [p];
  * G = bojaG [p];
  * B = bojaB [p];
}

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

  * R = bojaR [ColPos];
  * G = bojaG [ColPos];
  * B = bojaB [ColPos];
}

void increment_colour_pos (uint8_t i)
{
  bojaPos + = i;
  dok (colourPos & gt; = COLOR_WHEEL_LENGTH)
  {
    colourPos - = COLOR_WHEEL_LENGTH;
  }
}

// Unesite vrijednost od 0 do 255 da biste dobili vrijednost u boji.
// Boje su prijelaz r - g - b - natrag u r.
uint32_t Wheel (byte WheelPos) {
  WheelPos = 255 - WheelPos;
  ako (WheelPos <85) {
    povratna traka.Color (255 - WheelPos * 3, 0, WheelPos * 3);
  }
  ako (WheelPos <170) {
    WheelPos - = 85;
    povratna traka.Color (0, WheelPos * 3, 255 - WheelPos * 3);
  }
  WheelPos - = 170;
  povratna traka.Klor (WheelPos * 3, 255 - WheelPos * 3, 0);
}