Utilizzo di una scheda di sviluppo Servo per il controllo di LED NeoPixel

La scheda Simply Servos di Kitronik (Figura 1) risolve il problema di fornire un rail di alimentazione adeguato da 3 V a 12 V quando, in un progetto, si utilizzano più servo. La regolazione dell'alimentazione a 3 V incorporata e le basette pin sono un modo rapido per aggiungere un Raspberry Pi Pico per azionare i servo. Ma come fare con un dispositivo di altro tipo che ha un cavo a tre fili, richiede un'alimentazione a 5 V e può avere un notevole assorbimento di corrente? Come le stringhe di LED NeoPixel di Adafruit!

Figura 1: La scheda Simply Servos di Kitronik. (Immagine per gentile concessione di Kitronik)

Recentemente mi è venuta l'idea di creare un modellino notturno da uno dei miei aerei da combattimento RC. Potrei inserire qualsiasi microcontroller e trovare un modo per collegare le stringhe NeoPixel a un alimentatore. Ma come sarebbe se si potesse fare rapidamente usando dei connettori servo e se ciò facilitasse la manutenzione? La scheda Simply Servos non è ideale solo per i servo. La scelta di questa piattaforma ha semplificato il progetto e ha ridotto al minimo la necessità di un cablaggio personalizzato e di tutta una serie di connettori.

I dettagli della piattaforma di volo e un divertente video sulla conversione dell'aereo da combattimento sono presentati nel blog e nei link che potrete trovare in fondo a questo articolo. È stato utilizzato Arduino IDE per programmare il Pico per far funzionare i NeoPixel sulla base degli ingressi provenienti dal trasmettitore RC. Il progetto prevede l'utilizzo di una funzione marquee ai lati del corpo dell'aereo che risponde più velocemente con l'aumento dell'acceleratore. Quando la sera si fa più buia, i NeoPixel possono risultare fastidiosi per gli occhi a causa dell'eccessiva luminosità. Per dimmerare i LED si utilizza un canale ausiliario. Quando si atterra al buio, le luci di atterraggio si rivelano utili. Invece di aggiungere un altro canale, i NeoPixel inferiori diventano bianchi luminosi quando l'acceleratore è a una velocità pari o inferiore a quella di atterraggio. Ho usato una programmazione di base, ma c'è spazio per miglioramenti o funzioni aggiuntive da esplorare.

CopyArduino IDE Code:

//Rx throttle as LED speed control. Rx Aux 2 as dimmer. Channels 1 and 2 as inputs on Simply Servos.
//Remaining servo ports on board (channels 3-8, pins 4-9) used as NeoPixel outputs.
#include <neopixelconnect.h>

//Number of NeoPixels in each string
#define FIN_LEN 34  //Number of NeoPixels on each fin
#define BOT_LEN 28  //Number of NeoPixels on each bottom skid
#define AUX_LEN 61  //Number of NeoPixels on each auxiliary location
#define THRESH 60   //Landing versus flight throttle threshold

//Rx channel Pico GPIO inputs
#define THROT 2
#define AUX2 3

// Create an instance of NeoPixelConnect and initialize it for each strand of NeoPixels
// (pin, number of pixels in string, programmable IO location (0 or 1), programmable IO state machine usage (0-3))
NeoPixelConnect R_Aux(4, AUX_LEN, pio0, 0);
NeoPixelConnect L_Aux(5, AUX_LEN, pio1, 0);
NeoPixelConnect R_Bot(6, BOT_LEN, pio0, 1);
NeoPixelConnect L_Bot(7, BOT_LEN, pio1, 1);
NeoPixelConnect R_Fin(8, FIN_LEN, pio0, 2);
NeoPixelConnect L_Fin(9, FIN_LEN, pio1, 2);

uint8_t AuxSingLED;  //Single LED variable on auxiliary string

//Function - Get intensity level from Rx Aux2 output
uint8_t get_pixel_intensity() {
  return map(pulseIn(AUX2, HIGH), 900, 2200, 0, 255);
}

//Function - Get speed level from Rx Throttle output
uint8_t get_pixel_speed() {
  return map(pulseIn(THROT, HIGH), 990, 1902, 100, 0);
}

void setup() {
  pinMode(THROT, INPUT);  //Set Pico GPIO pin 2 as input
  pinMode(AUX2, INPUT);   //Set Pico GPIO pin 3 as input
}

void loop() {
  uint8_t LEDInten = get_pixel_intensity();  //Get NeoPixel intensity value
  uint8_t LEDSpeed = get_pixel_speed();      //Get NeoPixel speed value
  if (LEDSpeed < 10) LEDSpeed = 0;           //Dampen lower speed limit

  if (LEDSpeed < THRESH) {                                   //Throttle high color
    R_Bot.neoPixelFill(LEDInten, 0, 0, true);                //Fill string with red
    L_Bot.neoPixelFill(LEDInten, 0, 0, true);                //Fill string with red
  } else {                                                   //Throttle low color
    R_Bot.neoPixelFill(LEDInten, LEDInten, LEDInten, true);  //Fill string with white
    L_Bot.neoPixelFill(LEDInten, LEDInten, LEDInten, true);  //Fill string with white
  }

  R_Fin.neoPixelFill(0, LEDInten, 0, true);  //Fill string with green
  L_Fin.neoPixelFill(0, LEDInten, 0, true);  //Fill string with green

  R_Aux.neoPixelFill(0, 0, LEDInten, false);                           //Fill string with blue
  R_Aux.neoPixelSetValue(AuxSingLED, LEDInten, 0, 0, false);           //Set a NeoPixel to red
  R_Aux.neoPixelSetValue(AuxSingLED - 1, LEDInten / 10, 0, 0, false);  //Set trailing NeoPixel to dimmed red
  R_Aux.neoPixelSetValue(AuxSingLED + 1, LEDInten / 10, 0, 0, true);   //Set leading NeoPixel to dimmed red
  L_Aux.neoPixelFill(0, 0, LEDInten, false);                           //Fill string with blue
  L_Aux.neoPixelSetValue(AuxSingLED, LEDInten, 0, 0, false);           //Set a NeoPixel to red
  L_Aux.neoPixelSetValue(AuxSingLED - 1, LEDInten / 10, 0, 0, false);  //Set trailing NeoPixel to dimmed red
  L_Aux.neoPixelSetValue(AuxSingLED + 1, LEDInten / 10, 0, 0, true);   //Set leading NeoPixel to dimmed red

  AuxSingLED = AuxSingLED + 3;                //Marquis - move R_Aux and L_Aux red LEDs along NeoPixel string 3 pixels at a time.
  if (AuxSingLED >= AUX_LEN) AuxSingLED = 0;  //If at end of string, return to start.

  delay(LEDSpeed);  //Set how long to delay code execution cycle depending upon throttle level.
}

Arduino IDE Code END:
</neopixelconnect.h>

Listato 1: Codice IDE Arduino per il controllo delle stringhe NeoPixel.

L'intero programma beneficerà dell'eliminazione di qualsiasi funzione di ritardo e i LED potranno funzionare più velocemente regolando o mappando il valore di ingresso dall'acceleratore. Il resto delle stringhe è aperto a qualsiasi modello o colore si desideri. Occorre tenere presente che il pilota si affida a uno schema di luci riconoscibile per determinare l'orientamento e la direzione dell'aereo. Il volo notturno è divertente e allo stesso tempo impegnativo. Esercitatevi nel volo notturno nelle prime ore della sera, quando potete ancora vedere sia l'aereo che i suoi LED.

Altre risorse:

Video: Esplora il volo notturno RC con i LED NeoPixel

Blog: Come costruire un APR da combattimento RC a basso costo