"Magisk lampa" med Arduino

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

#define blank_pin 3 // Definierar faktiska BIT of PortD för blank - är Arduino UNO pin 3
#define latch_pin 2 // Definierar faktiska BIT för PortD för spärr - är Arduino UNO pin 2
# definiera klocka_pin 13 // som används av SPI, måste vara 13 SCK 13 på Arduino UNO
#definiera data_pin 11 // som används av SPI, måste vara stift MOSI 11 på Arduino UNO

# definiera rad 4
#definier KNAPP 5
# definiera PIN 6
#definiera POTPIN 7

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

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

byte röd [4];
byte grön [4];
byteblått [4];

int BAM_Bit, BAM_Counter = 0;

// *************************************************** ************************************************** ********** //
#definiera BAM_RESOLUTION 4
#definiera COLOR_WHEEL_LENGTH 256

uint8_t färgR [COLOR_WHEEL_LENGTH];
uint8_t färgG [COLOR_WHEEL_LENGTH];
uint8_t färgB [COLOR_WHEEL_LENGTH];
int16_t ColPos = 0;
uint16_t färgPos;
uint8_t R, G, B;

#definiera minPI 3.14159265358979323846
# definiera myDPI 1.2732395
# definiera myDPI2 0.40528473

int-knappPushCounter = 0;
int-knappStat = 0;
int lastButtonState = 0;
int POT;
int OLD_POT;

ogiltig installation ()
{
strip.begin ();
strip.setBrightness (50);
strip.show (); // Initiera alla pixlar till 'av'

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

fyll_färghjul ();
clearfast ();
}

void loop ()
{
buttonState = digitalRead (BUTTON);
 
  if (buttonState! = lastButtonState) {
    if (buttonState == HIGH) {
      buttonPushCounter ++;
    }
    annars {

    }
  }
  lastButtonState = buttonState;

  switch (knappPushCounter% 5)
  {
    fall 0:

      POT = karta (analogRead (POTPIN), 0, 1023, 0, 255);
      if (POT & lt; (OLD_POT * 0,95) || POT & gt; (OLD_POT * 1,05))
        {
          OLD_POT = POT; // spara det ändrade värdet
          fillTable_colorwheelRGB (POT, R, G, B);
          regnbåge (POT);
        }

        break;
    fall 1:

      POT = karta (analogRead (POTPIN), 0, 1023, 0, 255);
      if (POT & lt; (OLD_POT * 0,95) || POT & gt; (OLD_POT * 1,05))
        {
          OLD_POT = POT;
          get_colour (POT, & R, & G, & B);
          fyllbord (R, G, B);
          fyllning (POT);
        }

        break;

    fall 2:

      POT = karta (analogRead (POTPIN), 0, 1023, 0, 255);
      if (POT & lt; (OLD_POT * 0,95) || POT & gt; (OLD_POT * 1,05))
        {
          OLD_POT = POT;
          get_colour (POT, & R, & G, & B);
          fyllbord (R, G, B);
          fullWhite ();
        }

        break;
    fall 3:

      POT = karta (analogRead (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);
          regnbåge (POT);
        }

        break;
fall 4:
        clearfast ();
        fullWhite ();
        break;
  }
}

tom LED (int Y, int R, int G, int B)
{
  Y = begränsning (Y, 0, 7);
  
  R = begränsning (R, 0, 15);
  G = begränsning (G, 0, 15);
  B = begränsning (B, 0, 15);

  för (byte BAM = 0; BAM & BAM_RESOLUTION; BAM ++)
  {
    bitWrite (röd [BAM], Y, bitRead (R, BAM));

    bitWrite (grön [BAM], Y, bitRead (G, BAM));

    bitWrite (blå [BAM], Y, bitRead (B, BAM));
  }
}

ISR (TIMER1_COMPA_vect) {
  
PORTD | = ((1 & lt; myPI) {
    x - = 2 * myPI;
    g är 1;
  }

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

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

  återvända sinr;
}

// FAST COSINE APPROX
float myCos (float x) {
  returnera mySin (x + myPI / 2);
}

float myTan (float x) {
  returnera mySin (x) / myCos (x);
}

// SQUARE ROOT APPROX
float mySqrt (flyta in) {
  int16_t d = 0;
  int16_t in_ = in;
  flottörresultat = 2;
  
  för (d = 0; in_ & gt; 0; in_ & gt; = 1) {
    d ++;
  }
  
  för (int16_t i = 0; i & lt; d / 2; i ++) {
    resultat = resultat * 2;
  }
  
  för (int16_t i = 0; i & lt; 3; i ++) {
    resultat = 0,5 * (in / resultat + resultat);
  }
  
  returresultat;
}

// ABSOLUTVÄRDE
float myAbs (flyta in) {
  returnera (in) & gt; 0? (in) :-( in);
}

void fill_colour_wheel (void)
{
  flyta röd, grön, blå;
  flottör c, s;
  int32_t fas = 0;
  int16_t I = 0;

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

    röd = (I == 0? 1: 0) * s + (I == 1? 1: 0) * c;
    grön = (I == 1? 1: 0) * s + (I == 2? 1: 0) * c;
    blå = (I == 2? 1: 0) * s + (I == 0? 1: 0) * c;

    färgR [fas] = röd;
    färgG [fas] = grön;
    färgB [fas] = blå;

    if (++ fas & gt; = (1 + I) * COLOR_WHEEL_LENGTH / 3)
      I ++;
  }
}

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

  * R = färgR [p];
  * G = färgG [p];
  * B = färgB [p];
}

void get_next_colour (uint8_t * R, uint8_t * G, uint8_t * B)
{
  if (++ ColPos & gt; = COLOR_WHEEL_LENGTH)
    ColPos - = COLOR_WHEEL_LENGTH;

  * R = färgR [ColPos];
  * G = färgG [ColPos];
  * B = färgB [ColPos];
}

void increment_colour_pos (uint8_t i)
{
  färgPos + = i;
  medan (colourPos & gt; = COLOR_WHEEL_LENGTH)
  {
    färgPos - = COLOR_WHEEL_LENGTH;
  }
}

// Mata in ett värde 0 till 255 för att få ett färgvärde.
// Färgerna är en övergång r - g - b - tillbaka till r.
uint32_t Wheel (byte WheelPos) {
  WheelPos = 255 - WheelPos;
  if (WheelPos & lt; 85) {
    returlist. Färg (255 - WheelPos * 3, 0, WheelPos * 3);
  }
  if (WheelPos & lt; 170) {
    WheelPos - = 85;
    returlist. Färg (0, WheelPos * 3, 255 - WheelPos * 3);
  }
  WheelPos - = 170;
  returlist. Färg (WheelPos * 3, 255 - WheelPos * 3, 0);
}