Utiliser une carte de développement servo pour commander des LED NeoPixel

La carte Simply Servos de Kitronik (Figure 1) résout le problème de la fourniture d'un rail d'alimentation de 3 V – 12 V adéquat lors de l'utilisation de plusieurs servos dans un projet. La régulation de puissance 3 V et les embases mâles intégrées permettent d'ajouter rapidement un Raspberry Pi Pico pour faire fonctionner les servos. Mais qu'en est-il d'un autre dispositif qui est doté d'une sortie à trois fils, nécessite une puissance de 5 V et peut avoir une consommation de courant significative ? C'est le cas par exemple des rubans LED NeoPixel d'Adafruit !

Figure 1 : Carte Simply Servos de Kitronik. (Source de l'image : Kitronik)

Récemment, j'ai eu l'idée de créer un avion de nuit à partir de l'un de mes avions de combat radiocommandés. J'aurais pu ajouter n'importe quel microcontrôleur et trouver un moyen de connecter les rubans NeoPixel à une alimentation, mais je me suis dit : et si cela pouvait se faire rapidement en utilisant des sorties de servo et être facilement réparable ? La carte Simply Servos n'est pas uniquement réservée aux servos. Le choix de cette plateforme a simplifié ce projet et a réduit la nécessité d'avoir un câblage personnalisé et un ensemble de connecteurs.

Les détails de la plateforme volante et une vidéo amusante de la transformation de l'avion de combat sont disponibles via les liens fournis à la fin de cet article. L'IDE Arduino a été utilisé pour programmer le Pico afin de faire fonctionner les rubans NeoPixel en fonction de l'entrée de l'émetteur radiocommandé. Le plan consiste à utiliser sur les flancs de l'avion une fonction de bandeau lumineux qui défile plus vite à mesure que l'avion accélère. Lorsque la nuit tombe, les rubans LED NeoPixel peuvent faire mal aux yeux en raison de leur luminosité excessive. Un canal auxiliaire est utilisé pour atténuer l'intensité des LED. Enfin, lors de l'atterrissage de l'avion dans le noir, il serait pratique d'avoir des phares d'atterrissage. Plutôt que d'ajouter un autre canal, les LED NeoPixel sur le bas de l'avion s'illuminent en blanc lorsque l'avion vole à une vitesse égale ou inférieure à la vitesse d'atterrissage. J'ai utilisé une programmation de base, mais des améliorations restent envisageables, tout comme l'ajout de fonctionnalités supplémentaires.

CopierArduino 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>

Liste 1 : Code de l'IDE Arduino pour commander les rubans LED NeoPixel.

Le programme tout entier peut être amélioré en éliminant les fonctions impliquant un retard, et les LED peuvent fonctionner plus rapidement en manipulant la valeur d'entrée de l'accélérateur ou le mappage de la valeur d'entrée. Le reste des rubans LED peut refléter n'importe quels schémas ou couleurs souhaités. N'oubliez pas que le pilote se base sur un schéma lumineux reconnaissable pour déterminer l'orientation et la direction de l'avion. Le vol de nuit est à la fois amusant et délicat. Exercez-vous en début de soirée, quand vous pouvez encore voir l'avion tout en distinguant les LED.

Ressources supplémentaires :

Vidéo : Explore R/C Night Flying with NeoPixel LEDs

Blog : How to Build a Low-Cost RC Combat UAV