"Magic lamp" kasama si Arduino

Arduino / Mga LED / Mga pag-aayos

Ang orihinal na lampara na ginawa ng Mga Tagagamit sa ilalim ng palayaw tuenhidiy ay maaaring mabuksan at ito ay magaan ang ilaw mula sa loob. Ang kulay ng glow ay nababagay gamit ang isang variable na risistor at isang pindutan.

Ang disenyo ng luminaire ay may kasamang: isang spherical casing mula sa isang pang-industriya thermocouple, isang pambalot mula sa isang post ng push-button, isang cable gland ... Tingnan, kung ano ang isang magandang pambalot:

Ang kaso ng post button ay mula sa Schneider, uri ng XAPM1501H29. Ito ay gawa sa zinc alloy. Maaari mong, siyempre, gumamit ng isang bagay na mas simple din, ang resulta ay hindi magiging mas masahol pa. Para sa kagandahan, ang isang 20 mm polyamide o nikel cable gland ay nakadikit sa katawan, naka-install ito sa isang umiiral na butas.

Pinamamahalaan ang lahat ng board Arduino Nano. Mayroong dalawang uri ng mga ilaw na mapagkukunan: ang Neopixel Ring 16 module at 16 RGB LEDs na may isang karaniwang anode. Kinakailangan pa rin ang anim na microcircuits: tatlong shift registers 74HC595 at tatlong hanay ng mga composite transistors ULN2803. Well, ang mga maliit na bagay: tatlong capacitor sa 0.1 μF, 24 resistors sa 100 Ohms, isang transistor A1013 at isang power socket. Gumagamit ang board ng isang perfboard type na tinapay, ang aparato ay pinalakas ng isang limang boltahe na suplay ng kuryente.

Ang iskema sa una ay tila kumplikado, ngunit kung titingnan mo ito, ang lahat ay magiging malinaw:

Ang pindutan ay nagpapalipat-lipat ng mga mode, pinapayagan ka ng isang variable na risistor na pumili ng mga kulay ng glow ng kapwa LED ring at discrete RGB LEDs.

Kinukuha ng master ang pambalot mula sa thermocouple:

Mayroong dalawang butas sa loob nito, ang isa na may diameter na 21 mm, ang isa pa sa 32. Ang unang tuenhidiy ay gumagamit upang ikonekta ang pambalot sa katawan ng post na pindutan, ang pangalawa - kasama ang "ulo ng taong yari sa niyebe" kung saan matatagpuan ang pindutan.

Sa isang piraso ng isang breadboard-type na tinapay, ang master ay nagtipon ng isang dalawang palapag na istraktura ng RGB LEDs sa pamamagitan ng pagsasama ng kanilang mga anod. Ang mga wire mula sa lahat ng mga cathode at ang mga punto ng koneksyon ng anod ay output sa mga konektor. Nag-install ng diffuser:

Itala ang cable gamit ang konektor sa NeoPixel Ring 16 module:

Nagtitipon ng isang shift rehistro board ayon sa scheme:

Ang mga output ng Arduino na konektado sa board ng rehistro ay na-configure tulad ng sumusunod: resolusyon - 3, aldaba - 2, pag-clocking - 13, data - 11.

Pagkatapos ang wizard sa isa pang piraso ng breadboard ay nagtatayo ng adapter para sa Arduino Nano:

Ginagawa niya ang ulo ng tinatawag niya na isang taong yari sa niyebe, na may leeg mula sa isang piraso ng PVC pipe, naglalagay ng isang pindutan sa loob at ipinapakita ang isang cable mula dito:

Pinagsasama nito ang ulo ng isang taong yari sa niyebe, ang pambalot mula sa thermocouple at ang takip ng post na pindutan:

Nag-install ng isang variable na risistor na may isang control hawakan, isang selyo ng langis at isang terminal strip sa pindutan ng post na pabahay:

Sinusubukan kung paano magkasya ang Arduino Nano at ang shift register board:

Nag-uugnay ang lahat, kung paano ibukod ang mga board mula sa metal case - hindi ito malinaw:

Kumikislap:

Sketch

// ******************************************* ... ******************************************** ... ********** //
#nagsama
#nagsama

#define blank_pin 3 // Tinukoy ang aktwal na BIT ng PortD para sa blangko - ay Arduino UNO pin 3
#define latch_pin 2 // Tinutukoy ang aktwal na BIT ng PortD para sa latch - ay Arduino UNO pin 2
#define clock_pin 13 // na ginamit ng SPI, ay dapat na 13 SCK 13 sa Arduino UNO
#define data_pin 11 // na ginamit ng SPI, dapat na pin MOSI 11 sa 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 pula [4];
byte berde [4];
byte asul [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;

walang pag-setup ()
{
strip.begin ();
strip.setBightness (50);
strip.show (); // Unahin ang lahat ng mga piksel upang 'off'

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

punan_colour_wheel ();
malinaw ();
}

walang bisa loop ()
{
buttonState = digitalRead (BUTTON);
 
  kung (buttonState! = lastButtonState) {
    kung (buttonState == HIGH) {
      buttonPushCounter ++;
    }
    iba pa {

    }
  }
  lastButtonState = buttonState;

  lumipat (buttonPushCounter% 5)
  {
    kaso 0:

      POT = mapa (analogRead (POTPIN), 0, 1023, 0, 255);
      kung (POT & lt; (OLD_POT * 0.95) || POT & gt; (OLD_POT * 1.05))
        {
          OLD_POT = POT; // i-save ang nabago na halaga
          punanTable_colorwheelRGB (POT, R, G, B);
          bahaghari (POT);
        }

        masira;
    kaso 1:

      POT = mapa (analogRead (POTPIN), 0, 1023, 0, 255);
      kung (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);
          pagpuno (POT);
        }

        masira;

    kaso 2:

      POT = mapa (analogRead (POTPIN), 0, 1023, 0, 255);
      kung (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);
          buongWhite ();
        }

        masira;
    kaso 3:

      POT = mapa (analogRead (POTPIN), 0, 1023, 0, 255);
      kung (POT & lt; (OLD_POT * 0.95) || POT & gt; (OLD_POT * 1.05))
        {
          OLD_POT = POT;
          fillTable (0, 0, 0);
          bahaghari (POT);
        }

        masira;
kaso 4:
        malinaw ();
        buongWhite ();
        masira;
  }
}

walang bisa LED (int Y, int R, int G, int B)
{
  Y = pilitin (Y, 0, 7);
  
  R = pilitin (R, 0, 15);
  G = pilitin (G, 0, 15);
  B = pilitin (B, 0, 15);

  para sa (byte BAM = 0; BAM & lt; BAM_RESOLUTION; BAM ++)
  {
    bitWrite (pula [BAM], Y, bitRead (R, BAM));

    bitWrite (berde [BAM], Y, bitRead (G, BAM));

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

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

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

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

  ibalik ang sinr;
}

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

lumutang myTan (float x) {
  ibalik ang mySin (x) / myCos (x);
}

// SQUARE ROOT APPROX
lumutang mySqrt (lumutang sa) {
  int16_t d = 0;
  int16_t in_ = sa;
  resulta ng float = 2;
  
  para sa (d = 0; in_ & gt; 0; in_ & gt; & gt; = 1) {
    d ++;
  }
  
  para sa (int16_t i = 0; i & lt; d / 2; i ++) {
    resulta = resulta * 2;
  }
  
  para sa (int16_t i = 0; i & lt; 3; i ++) {
    resulta = 0.5 * (sa / resulta + resulta);
  }
  
  resulta ng pagbabalik;
}

// VALUE NG ABSOLUTE
lumutang myAbs (lumutang sa) {
  bumalik (sa) & gt; 0? (sa) :-( in);
}

walang laman na fill_colour_wheel (walang bisa)
{
  lumutang pula, berde, asul;
  lumutang c, s;
  int32_t phase = 0;
  int16_t I = 0;

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

    pula = (I == 0? 1: 0) * s + (I == 1? 1: 0) * c;
    berde = (I == 1? 1: 0) * s + (I == 2? 1: 0) * c;
    asul = (I == 2? 1: 0) * s + (I == 0? 1: 0) * c;

    colourR [phase] = pula;
    colourG [phase] = berde;
    colourB [phase] = asul;

    kung (+ + phase & gt; = (1 + I) * COLOR_WHEEL_LENGTH / 3)
      Ako ++;
  }
}

walang saysay na pagkuha_colour (int16_t p, uint8_t * R, uint8_t * G, uint8_t * B)
{
  kung (p & gt; = COLOR_WHEEL_LENGTH)
    p - = COLOR_WHEEL_LENGTH;

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

walang bisa ng__xtxt_colour (uint8_t * R, uint8_t * G, uint8_t * B)
{
  kung (++ ColPos & gt; = COLOR_WHEEL_LENGTH)
    ColPos - = COLOR_WHEEL_LENGTH;

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

walang bisa pag-akit_colour_pos (uint8_t i)
{
  colourPos + = i;
  habang (colourPos & gt; = COLOR_WHEEL_LENGTH)
  {
    colourPos - = COLOR_WHEEL_LENGTH;
  }
}

// Mag-input ng isang halaga 0 hanggang 255 upang makakuha ng isang halaga ng kulay.
// Ang mga kulay ay isang paglipat r - g - b - pabalik sa r.
uint32_t Wheel (byte WheelPos) {
  WheelPos = 255 - WheelPos;
  kung (WheelPos & lt; 85) {
    return strip.Color (255 - WheelPos * 3, 0, WheelPos * 3);
  }
  kung (WheelPos & lt; 170) {
    WheelPos - = 85;
    return strip.Color (0, WheelPos * 3, 255 - WheelPos * 3);
  }
  WheelPos - = 170;
  return strip.Color (WheelPos * 3, 255 - WheelPos * 3, 0);
}

Mga tseke: