"ตะเกียงวิเศษ" กับ Arduino

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

#define blank_pin 3 // กำหนด BIT จริงของ PortD สำหรับ blank - คือ Arduino UNO pin 3
#define latch_pin 2 // กำหนด BIT จริงของ PortD สำหรับ latch - คือ Arduino UNO pin 2
#define clock_pin 13 // ใช้โดย SPI ต้องเป็น 13 SCK 13 บน Arduino UNO
#define data_pin 11 // ใช้โดย SPI ต้องเป็น pin MOSI 11 บน Arduino UNO

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

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

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

byte red [4];
ไบต์สีเขียว [4];
ไบต์สีน้ำเงิน [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 buttonPushCounter = 0;
int buttonState = 0;
int lastButtonState = 0;
int POT;
int OLD_POT;

การตั้งค่าเป็นโมฆะ ()
{
strip.begin ();
strip.setBrightness (50);
strip.show (); // เริ่มต้นพิกเซลทั้งหมดเป็น 'ปิด'

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 (ปุ่ม INPUT_PULLUP);

SPI.begin ();
อินเตอร์รัปต์ ();

fill_colour_wheel ();
clearfast ();
}

เป็นโมฆะห่วง ()
{
buttonState = digitalRead (ปุ่ม);
 
  if (buttonState! = lastButtonState) {
    ถ้า (buttonState == สูง) {
      buttonPushCounter ++;
    }
    อื่น {

    }
  }
  lastButtonState = buttonState;

  สวิตช์ (buttonPushCounter% 5)
  {
    กรณีที่ 0:

      POT = map (analogRead (POTPIN), 0, 1023, 0, 255);
      ถ้า (POT & lt; (OLD_POT * 0.95) || POT & gt; (OLD_POT * 1.05)
        {
          OLD_POT = POT; // บันทึกค่าที่เปลี่ยนแปลง
          fillTable_colorwheelRGB (POT, R, G, B);
          รุ้ง (POT);
        }

        ทำลาย;
    กรณีที่ 1:

      POT = map (analogRead (POTPIN), 0, 1023, 0, 255);
      ถ้า (POT & lt; (OLD_POT * 0.95) || POT & gt; (OLD_POT * 1.05)
        {
          OLD_POT = POT;
          get_colour (POT, & R, & G, & B);
          fillTable (R, G, B);
          การเติม (POT);
        }

        ทำลาย;

    กรณีที่ 2:

      POT = map (analogRead (POTPIN), 0, 1023, 0, 255);
      ถ้า (POT & lt; (OLD_POT * 0.95) || POT & gt; (OLD_POT * 1.05)
        {
          OLD_POT = POT;
          get_colour (POT, & R, & G, & B);
          fillTable (R, G, B);
          fullWhite ();
        }

        ทำลาย;
    กรณีที่ 3:

      POT = map (analogRead (POTPIN), 0, 1023, 0, 255);
      ถ้า (POT & lt; (OLD_POT * 0.95) || POT & gt; (OLD_POT * 1.05)
        {
          OLD_POT = POT;
          fillTable (0, 0, 0);
          รุ้ง (POT);
        }

        ทำลาย;
กรณีที่ 4:
        clearfast ();
        fullWhite ();
        ทำลาย;
  }
}

โมฆะ LED (int Y, int R, int G, int B)
{
  Y = ข้อ จำกัด (Y, 0, 7);
  
  R = ข้อ จำกัด (R, 0, 15);
  G = ข้อ จำกัด (G, 0, 15);
  B = ข้อ จำกัด (B, 0, 15);

  สำหรับ (ไบต์ BAM = 0; BAM & lt; BAM_RESOLUTION; BAM ++)
  {
    bitWrite (แดง [BAM], Y, bitRead (R, BAM));

    bitWrite (สีเขียว [BAM], Y, bitRead (G, BAM));

    bitWrite (สีน้ำเงิน [BAM], Y, bitRead (B, BAM));
  }
}

ISR (TIMER1_COMPA_vect) {
  
PORTD | = ((1 & lt; myPI) {
    x - = 2 * myPI;
    g คือ 1;
  }

  ในขณะที่ (! g & (x & lt; -myPI)) {
    x + = 2 * myPI;
  }

  sinr = myDPI * x - myDPI2 * x * myAbs (x);
  sinr = 0.225 * (sinr * myAbs (sinr) -sinr) + sinr;

  กลับบาป
}

// FAST COSINE ไปอีกประมาณ
ลอย myCos (ลอย x) {
  ส่งคืน mySin (x + myPI / 2);
}

ลอย myTan (float x) {
  ส่งคืน mySin (x) / myCos (x);
}

// SQUARE ROOT ไปที่
ลอย mySqrt (ลอยใน) {
  int16_t d = 0;
  int16_t in_ = in;
  ผลลอย = 2;
  
  สำหรับ (d = 0; in_ & gt; 0; in_ & gt; & gt; = 1) {
    d ++;
  }
  
  สำหรับ (int16_t i = 0; i & lt; d / 2; i ++) {
    ผล = ผลลัพธ์ * 2;
  }
  
  สำหรับ (int16_t i = 0; i & lt; 3; i ++) {
    ผล = 0.5 * (ใน / ผล + ผล);
  }
  
  ผลตอบแทน;
}

// ค่า ABSOLUTE
ลอย myAbs (ลอยใน) {
  ส่งคืน (ใน) & gt; 0? (ใน) :-( ใน);
}

เป็นโมฆะ fill_colour_wheel (เป็นโมฆะ)
{
  แดงลอยเขียวน้ำเงิน
  ลอย c, s;
  int32_t phase = 0;
  int16_t I = 0;

  ในขณะที่ (เฟส & lt; COLOR_WHEEL_LENGTH)
  {
    s = (1 & lt; & lt; BAM_RESOLUTION) * mySin (myPI * (3 * เฟส - I * COLOR_WHEEL_LENGTH) / (2 * COLOR_WHEEL_LENGTH);
    c = (1 & lt; & lt; BAM_RESOLUTION) * myCos (myPI * (3 * เฟส - I * COLOR_WHEEL_LENGTH) / (2 * COLOR_WHEEL_LENGTH);

    red = (I == 0? 1: 0) * s + (I == 1? 1: 0) * c;
    สีเขียว = (I == 1? 1: 0) * s + (I == 2? 1: 0) * c;
    blue = (I == 2? 1: 0) * s + (I == 0? 1: 0) * c;

    colourR [phase] = red;
    colourG [phase] = green;
    colourB [phase] = blue;

    if (++ phase & gt; = (1 + I) * COLOR_WHEEL_LENGTH / 3)
      ฉัน ++;
  }
}

ถือเป็นโมฆะ get_colour (int16_t p, uint8_t * R, uint8_t * G, uint8_t * B)
{
  ถ้า (p & gt; = COLOR_WHEEL_LENGTH)
    p - = COLOR_WHEEL_LENGTH;

  * R = colourR [p];
  * G = colourG [p];
  * B = colourB [p];
}

ถือเป็นโมฆะ get_next_colour (uint8_t * R, uint8_t * G, uint8_t * B)
{
  if (++ ColPos & gt; = COLOR_WHEEL_LENGTH)
    ColPos - = COLOR_WHEEL_LENGTH;

  * R = colourR [ColPos];
  * G = colourG [ColPos];
  * B = colourB [ColPos];
}

โมฆะ increment_colour_pos (uint8_t i)
{
  colourPos + = i;
  ในขณะที่ (colourPos & gt; = COLOR_WHEEL_LENGTH)
  {
    colourPos - = COLOR_WHEEL_LENGTH;
  }
}

// ป้อนค่า 0 ถึง 255 เพื่อรับค่าสี
// การเปลี่ยนสีเป็น r - g - b - กลับสู่ r
uint32_t Wheel (ไบต์ WheelPos) {
  WheelPos = 255 - WheelPos;
  ถ้า (WheelPos & lt; 85) {
    แถบย้อนกลับสี (255 - WheelPos * 3, 0, WheelPos * 3);
  }
  ถ้า (WheelPos & lt; 170) {
    WheelPos - = 85;
    แถบย้อนกลับสี (0, WheelPos * 3, 255 - WheelPos * 3);
  }
  WheelPos - = 170;
  แถบย้อนกลับสี (WheelPos * 3, 255 - WheelPos * 3, 0);
}