Uso de una placa de desarrollo para servos para controlar luces LED NeoPixel

La placa de servos Simply Servos de Kitronik (Figura 1) resuelve el problema de proporcionar una línea de alimentación adecuada de 3 V a 12 V cuando se utilizan varios servos en un proyecto. La regulación de alimentación de 3 V incorporada y los conectores de pines son una forma rápida de agregar una Raspberry Pi Pico para operar los servos. Pero, ¿qué sucede con un dispositivo diferente que tenga un conductor de tres hilos, requiera una alimentación de 5 V y consuma una corriente significativa? ¡Como las tiras LED NeoPixel de Adafruit!

Figura 1: La placa Simply Servos de Kitronik. (Fuente de la imagen: Kitronik)

Recientemente, tuve la idea de convertir uno de mis aviones de combate a control remoto en uno para vuelos nocturnos. Podría incluir prácticamente cualquier microcontrolador y encontrar una forma de conectar las tiras NeoPixel a una fuente de alimentación, pero ¿y si se pudiera hacer de forma rápida utilizando conectores servo y con un mantenimiento sencillo? La placa Simply Servos no está limitada a servos. La elección de esta plataforma agilizó el proyecto y redujo la necesidad de cableado personalizado y de numerosos conectores.

Los detalles de la plataforma de vuelo y un video divertido que muestra cómo se convierte el avión de combate se presentan en los enlaces del blog y el video que figuran al final de este artículo. Se utilizó el IDE de Arduino para programar la Pico y ejecutar los NeoPixeles en función de las señales del transmisor a control remoto. El plan es utilizar una función de marquesina en los costados del chasis del avión, la que aumenta su velocidad de persecusión a medida que se incrementa el acelerador. A medida que oscurece, el brillo excesivo de los Neopixeles puede resultar incómodo para la vista. Para atenuar las luces LED, se utiliza un canal auxiliar. Por último, al aterrizar el avión en la oscuridad, sería útil tener luces de aterrizaje. En lugar de agregar otro canal, los NeoPixeles inferiores se iluminan en blanco brillante cuando el acelerador está a la velocidad de aterrizaje o por debajo de ella. Utilicé una programación básica, pero es posible optimizarla o explorar funciones adicionales.

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

Listado 1: Código IDE de Arduino para controlar las tiras NeoPixel.

Todo el programa se beneficiará de la eliminación de cualquier función de retardo. Las luces LED pueden funcionar más rápido manipulando el valor de entrada del acelerador o ajustando el mapeo del valor de entrada. El resto de las tiras se pueden configurar con cualquier patrón o color que se desee. Tenga en cuenta que el piloto depende de un patrón de luces reconocible para determinar la orientación y el rumbo de la aeronave. Volar de noche es divertido y retador a la vez. Practique el vuelo nocturno en las primeras horas de la noche, cuando aún pueda ver el avión y sus luces LED al mismo tiempo.

Recursos adicionales:

Video: Explore el vuelo nocturno a control remoto con las luces LED NeoPixel

Blog: Cómo construir un UAV de combate a control remoto de bajo costo