"Maaginen lamppu" Arduinon kanssa

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

#define blank_pin 3 // Määrittää PortD: n todellisen BIT: n tyhjälle - on Arduino UNO-nasta 3
#define latch_pin 2 // Määrittää portD: n todellisen BIT: n salpalle - on Arduino UNO-nasta 2
#define clock_pin 13 // SPI: n käyttämä, sen on oltava 13 SCK 13 Arduino UNO: ssa
#define data_pin 11 // SPI: n käyttämä, tulee olla MOSI 11 -tappi Arduino UNO: ssa

#define ROW 4
#define Button 5
#määritä PIN 6
#definine POTPIN 7

Adafruit_NeoPixel-nauha = Adafruit_NeoPixel (16, PIN, NEO_GRB + NEO_KHZ800);

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

tavunpunainen [4];
tavunvihreä [4];
tavun sininen [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-painikePushCounter = 0;
int buttonState = 0;
int lastButtonState = 0;
int POT;
int OLD_POT;

tyhjä asennus ()
{
strip.begin ();
strip.setBrightness (50);
strip.show (); // Alusta kaikki pikselit pois päältä

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

noInterrupts ();

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

pinMode (salpa_pin, OUTPUT);
pinMode (data_pin, OUTPUT);
pinMode (kellotappi, OUTPUT);

pinMode (ROW, OUTPUT);
pinMode (PAINIKE, INPUT_PULLUP);

SPI.begin ();
keskeyttää ();

fill_colour_wheel ();
selkeä ();
}

tyhjä silmukka ()
{
buttonState = digitalRead (BUTTON);
 
  if (buttonState! = lastButtonState) {
    if (buttonState == KORKEA) {
      buttonPushCounter ++;
    }
    muuten {

    }
  }
  lastButtonState = buttonState;

  kytkin (buttonPushCounter% 5)
  {
    tapaus 0:

      POT = kartta (analoginen lukeminen (POTPIN), 0, 1023, 0, 255);
      if (POT & lt; (OLD_POT * 0,95) || POT> (OLD_POT * 1.05))
        {
          OLD_POT = POT; // tallenna muutettu arvo
          fillTable_colorwheelRGB (POT, R, G, B);
          sateenkaari (POT);
        }

        break;
    tapaus 1:

      POT = kartta (analoginen lukeminen (POTPIN), 0, 1023, 0, 255);
      if (POT & lt; (OLD_POT * 0,95) || POT> (OLD_POT * 1.05))
        {
          OLD_POT = POT;
          saada väri (POT, & R, & G, & B);
          fillTable (R, G, B);
          täyttö (POT);
        }

        break;

    tapaus 2:

      POT = kartta (analoginen lukeminen (POTPIN), 0, 1023, 0, 255);
      if (POT & lt; (OLD_POT * 0,95) || POT> (OLD_POT * 1.05))
        {
          OLD_POT = POT;
          saada väri (POT, & R, & G, & B);
          fillTable (R, G, B);
          täysvalkoinen ();
        }

        break;
    tapaus 3:

      POT = kartta (analoginen lukeminen (POTPIN), 0, 1023, 0, 255);
      if (POT & lt; (OLD_POT * 0,95) || POT> (OLD_POT * 1.05))
        {
          OLD_POT = POT;
          fillTable (0, 0, 0);
          sateenkaari (POT);
        }

        break;
tapaus 4:
        selkeä ();
        täysvalkoinen ();
        break;
  }
}

tyhjä LED (int Y, int R, int G, int B)
{
  Y = rajoitus (Y, 0, 7);
  
  R = rajoitus (R, 0, 15);
  G = rajoitus (G, 0, 15);
  B = rajoitus (B, 0, 15);

  varten (tavu BAM = 0; BAM  0; in_> g>; 1) {
    d ++;
  }
  
  varten (int16_t i = 0; i  0 ((in) :-( in);
}

tyhjä fill_colour_wheel (tyhjä)
{
  kellu punainen, vihreä, sininen;
  kellua c, s;
  int32_t vaihe = 0;
  int16_t I = 0;

  kun taas (vaihe  = (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 = väriR [p];
  * G = väriG [p];
  * B = väriB [p];
}

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

  * R = väriR [ColPos];
  * G = väriG [ColPos];
  * B = väriB [ColPos];
}

mitätön lisäys_väri_postit (uint8_t i)
{
  colourPos + = i;
  kun taas (colourPos & gt; = COLOR_WHEEL_LENGTH)
  {
    colourPos - = COLOR_WHEEL_LENGTH;
  }
}

// Syötä arvo 0 - 255 saadaksesi väriarvo.
// Värit ovat siirtymä r - g - b - takaisin r: ään.
uint32_t Wheel (tavu WheelPos) {
  WheelPos = 255 - WheelPos;
  if (WheelPos <85) {
    paluuliuska.Väri (255 - WheelPos * 3, 0, WheelPos * 3);
  }
  if (WheelPos <170) {
    WheelPos - = 85;
    paluuliuska.Väri (0, WheelPos * 3, 255 - WheelPos * 3);
  }
  WheelPos - = 170;
  paluuliuska.Väri (WheelPos * 3, 255 - WheelPos * 3, 0);
}