Archivo de la etiqueta: arduino

Conexión de un receptor RC al computador, emulando Joystick USB

Pues un hack rápido.

Quería conectar mi transmisor de RC al computador, para poder usar los simuladores de radio control, especialmente el VRC Pro, usando los componentes que tenía a la mano.

Tenía una placa Digispark, que usa un micro ATTINY85 emulando un dispositivo Joystick HID. Conectándolo al receptor RC podemos usar la pistola del transmisor, como un joystick en el computador (inalámbrico!) y usarlo dentro del simulador.

El código fuente, y el esquema de conexión , se encuentran en mi repositorio de github https://github.com/patolin/rc-receiver-joystick

 

Necesitas visualizar información con tu Arduino? Nada mejor que un LCD a color

En este post, vamos a revisar el Color LCD Shield, fabricado por Elecfreaks y distribuido por www.dx.com, que viene listo para usar con cualquier placa Arduino.

DSC00252

Este shield tiene las siguientes características:

  • Display a color de 128x128px, basado en el display Nokia 6100
  • 4096 colores (profundidad de color de 12 bits)
  • Interfaz I2C (requiere unos pocos pines para funcionar)
  • Control de iluminación del backlight, mediante PWM en el pin 10 del arduino
  • Joystick de 5 posiciones, conectado a las entradas A0-A4 (deben ser configuradas como entradas digitales)
  • Regulación automática de 3.3v (no requiere modificaciones adicionales al Arduino)

El precio de este shield es bastante conveniente (19.xx con envío gratis desde China), y la calidad de fabricación es excelente. El item viene debidamente empacado, protegiendo con gomaespuma la pantalla y los pines de conexión, evitando las pantallas rotas o pines doblados en el largo viaje desde el otro lado del mundo.

Para esta prueba, vamos a usar los siguientes componentes:

Por que usar un LCD gráfico en lugar del clásico shield LCD 16×2? bueno, aquí es cuestión de gustos, y de la aplicación que le querramos dar. Como ejemplo del funcionamiento del Shield, y para ilustrar las funciones disponibles para el mismo, vamos a programar un voltímetro, que mida entre 0 y 5v, y que nos grafique en tiempo real las variaciones de voltaje ingresadas por el pin A5 de nuestro Arduino Uno.

Primero, debemos descargar e instalar la librería ColorLCDShield, que la puedes descargar de este enlace. Esta librería debe ser descomprimida en la carpeta “Libraries” de tu instalación del Arduino IDE, antes de empezar con nuestra prueba.

Primero, debemos incializar el LCD, para lo cual usamos los siguientes comandos:

pinMode(10, OUTPUT);
analogWrite(10, 1023); 
lcd.init(PHILLIPS); 
lcd.contrast(40);

Como podemos ver en este fragmento de código, el pin 10 de nuestro arduino controlará la intencidad del backlight mediante PWM. El valor de 40 para el contraste es un valor recomendado por el fabricante, así que no hay mucha explicación sobre dicho valor.

A continuación, luego de inicializada la pantalla, procedemos a dibujar la grilla de fondo. Para esto, vamos a usar el siguiente código:

  int x,y;  
  lcd.clear(BLACK);  
  lcd.setStr("Datalogger 2013 ", 2, 0, RED, WHITE);
  lcd.setStr("www.patolin.com ", 112, 1, BLUE, WHITE);
  for (x=1;x< =132;x+=20) {
       lcd.setLine(30,x,110,x, GRAY);
  } 
  for (y=30;y<=110;y+=20) {
       lcd.setLine(y,1,y,132, GRAY);  
  }
  lcd.setRect(30,2,110,129, 0, MAGENTA);

Dentro de este bloque, como podemos observar, usamos rutinas para limpiar la pantalla lcd.clear(BLACK);, escribir strings lcd.setStr(“Datalogger 2013 “, 2, 0, RED, WHITE);, dibujar líneas lcd.setLine(30,x,110,x, GRAY); y dibujar rectángulos lcd.setRect(30,2,110,129, 0, MAGENTA);.

Todas estas funciones, y el listado de colores disponibles como constantes para facilidad de uso, se encuentran detallados dentro de la ayuda de la librería del display.

Lo que vamos a hacer con nuestro arduino, es leer el valor del potenciómetro conectado en el puerto A5, y graficarlo en escala, dentro de la grilla que dibujamos previamente. El momento que el gráfico de la señal llegue al borde derecho de la grilla, limpiaremos la pantalla y empezaremos desde el borde izquierdo. Les dejo el código completo que estoy usando.

#include <ColorLCDShield.h> 

LCDShield lcd;  
int buttonPins[5] = {A0, A1, A2, A3, A4};  

void setup()
{
  pinMode(10, OUTPUT);
  analogWrite(10, 1023); //PWM control blacklight
  lcd.init(PHILLIPS);  // Initializes lcd, using an PHILIPSdriver
  lcd.contrast(40);  // -51's usually a good contrast value

  dibujaGrilla();
}

void dibujaGrilla() {

  int x,y;  
  lcd.clear(BLACK);  
  lcd.setStr("Datalogger 2013 ", 2, 0, RED, WHITE);
  lcd.setStr("www.patolin.com ", 112, 1, BLUE, WHITE);
  for (x=1;x< =132;x+=20) {
       lcd.setLine(30,x,110,x, GRAY);
  } 
  for (y=30;y<=110;y+=20) {        lcd.setLine(y,1,y,132, GRAY);     }   lcd.setRect(30,2,110,129, 0, MAGENTA); } void dibujaPunto(int x,int valADC) {   // ajustamos el valor del adc para la escala del grafico   int valor;   valor=valADC/20;   lcd.setPixel(RED,(110-valor),x); } void loop() {   int x=3;   int valor;   while(1) {     if (x>128) { x=3; dibujaGrilla();}
    valor=analogRead(A5);
    dibujaPunto(x,valor);
    delay(100);

    x++;
  }
}

Luego de cargar el código en el Arduino, el resultado es excelente! hemos creado con unas pocas líneas de código, un datalogger gráfico, que puede servir como base para muchas aplicaciones más. Les dejo un pequeño video del resultado.

Como podemos observar, este LCD Shield es bastante práctico, y es una gran mejora sobre el LCD 16×2 que casi siempre usamos en nuestros proyectos, para resumir sus características, podemos lanzar la siguiente comparativa:

A favor:

  • Bajo costo
  • Envío gratis desde dx.com
  • Incluye joystick de 5 posiciones
  • Interfaz I2C reduce el número de pines usados
  • Librerías listas para generar texto y gráficos
  • Facil uso y de facil integración en tus proyectos con Arduino

En contra

  • Largo tiempo de espera para recibirlo
  • el Joystick utiliza 5 pines (A0-A4) dejando solo una entrada analógica disponible (podría arreglarse cambiando los pines usados, conectándolo a un arduino nano o pro)
  • La actualización del display es un poco lenta, para algunas aplicaciones (podría ser un poco lenta si queremos usarla para un osciloscopio digital)

 

 

Osciloscopio con Stellaris Launchpad – Actualización

Todo el mundo quiere un osciloscopio! (bueno, todos los que trabajan en electrónica jejeje), y para no quitarme el gustito de construir un osciloscopio digital, desde cero, hice algunas pruebas con mi stellaris launchpad, que como comentaba en un post anterior, logré que muestree a casi 1Msps. Modificando un poco el código del stellaris, bajé la velocidad de muestreo a 125Ksps, e hice algunas capturas de la señal PPM que genera mi transmisor de RC basado en Arduino.

Para visualizar la señal armé una pequeña app en Visual Basic 2010, que recibe los datos del puerto serie del stellaris, y los grafica sobre un Chart Control, que resulta que es más facil de usar de lo que han pensado.

Les dejo un par de fotos, y el código fuente del Stellaris y de  la Aplicación de Visual Basic

Captura PPM a 125Ksps, 2048 muestras

dso

 

Captura PPM a 125Ksps, 4096 muestras

dso1

 

 

 

Freaduino Uno Review

Como habrán escuchado, la plataforma Arduino, es una plataforma electrónica abierta, diseñada para la creación de prototipos de hardware y software, pensando en gente que no tiene mucha experiencia con microcontroladores y electrónica en general.

En mi opinión personal, al haber estudiado a detalle algunos microcontroladores,pasando por el Motorola 68HC11 y el Intel 8051, hasta los modelos un poco mas actuales de Microchip (como el 18F4550, que he usado en muchos de mis proyectos), puedo decirles que la plataforma Arduino, dentro de sus limitaciones de hardware, nos brinda una extremada facilidad al momento de desarrollar aplicaciones de electrónica, que requieran del uso de un microcontrolador.

Dado que Arduino es una plataforma de código abierto, era de esperarse que empiecen a comercializarse “Clones” o incluso versiones mejoradas de la placa original. En este caso, vamos a analizar al Freaduino Uno, que lo puedes conseguir en DealExtreme, aun precio realmente bajo. Mucha gente tiene miedo de comprar en estos sitios mayoristas, que distribuyen desde la China, pero he realizado varias compras desde este sitio, y nunca he tenido problemas con los pedidos, el soporte al cliente es excelente, y los precios son muy convenientes.

freaduino3

Características

Como lo mencionamos, el Freaduino Uno está basado en el Arduino Uno, por lo que tiene características base similares. Las características completas las podemos observar en la siguiente tabla:

 

Freaduino Uno

Arduino Uno

Microcontrolador

ATMega 328P (SMD)

ATMega 328 (DIP)

Memoria Flash

32Kb

32Kb

Memoria Ram

2Kb

2Kb

Memoria EEPROM

1Kb

1Kb

E/S Digitales

14

13

E/S Analógicas

6

6

E/S PWM

6 (compartidas con las digitales)

6 (compartidas con las digitales)

Voltaje de Operación

3.3V/5V seleccionable

5V

Voltaje de Alimentación

7 a 23Vcc

7 a 12 Vcc

Corriente de salida máx.

800mA (3.3V) / 2000mA (5V)

50mA (3.3V) / 500mA (5V)

Pines dedicados (IIC/UART)

Si

No

Rieles Vcc y Gnd para E/S

Si

No

Tipo de conector USB

mini USB

USB tipo B

Precio

$ 18.60 (envío gratis desde dx.com)

$ 25.00 aprox (+ envío desde arduino.cc)

Si comparamos directamente las características, vemos que tenemos una placa muy superior al Arduino original, sin tomar en cuenta el valor adicional de un menor costo, que incluye el envío hasta la puerta de tu casa. Como es de esperar, el Freaduino Uno es compatible 100% con el IDE de Arduino, y los Shields diseñados para el mismo.

Por el precio de compra, se incluye un cable USB, para poder conectar la placa a nuestro computador, y poder programarla.

freaduinocable

El mayor plus de esta placa, comparada con la original de Arduino (o varios clones que existen en el mercado) es la inclusión de los headers para conexiones externas, que incluyen +Vcc y Gnd. Estos headers están claramente señalados al pin que corresponden, y nos brindan una gran ayuda el momento de conectar servomotores o sensores, eliminando la necesidad de incluir un shield de sensores para dichas conexiones.

2013-06-18_21-26-17_415

Otra función adicional, que nos podrá resultar super útil a futuro, es la inclusión de un selector de voltaje de trabajo. Todas las tarjetas Arduino tienen una salida de voltaje de referencia de 3.3v, pero el microcontrolador siempre funcionará a 5Vcc internamente. El Freaduino Uno posee un selector de voltaje de operación que  nos permite que todo el microcontrolador opere a 3.3v. Esto nos resulta útil para interconectar nuevos dispositivos (transmisores Bluetooth, pantallas LCD gráficas, acelerómetros, giroscopios, etc) que requieran este voltaje de funcionamiento, eliminando el requerimiento de componentes adicionales para la conexión.

 freaduino2

Instalación

La instalación del Freaduino Uno es identica a la del Arduino original. Basta con descargar el Arduino IDE, conectar la tarjeta al puerto USB con el cable provisto, e instalar los drivers que se incluyen dentro del IDE. Únicamente debemos seleccionar “Arduino Uno” de la lista de dispositivos compatibles, y escoger el puerto COM respectivo, según se instale en nuestro computador.

Para finalizar, podemos resumir toda esta revisión, en los siguientes pros y contras de esta tarjeta compatible con arduino:

Pros:

  • Compatible 100% con el Arduino Uno, en Programación y Shields existentes
  • Bajo Costo
  • Excelente calidad de manufactura
  • Pines de E/S con alimentación incluida (ideales para conectar servos o sensores)
  • Mayor capacidad de corriente de salida
  • Selección de voltaje de operación mediante un switch (3.3v o 5v)
  • El uso de componentes SMD ahorra espacio, y crea una disposición de placa más limpia
  • El regulador de voltaje switching a la entrada de alimentación, permite un mayor rango de voltajes de entrada.
  • Chip FTDI reemplazado por un ATMega8U, para la conexión USB con el computador
  • Leds integrados y boton de reset de facil acceso, al tener Shields conectados
  • Envío gratis desde dx.com

 

Contras:

  • Tiempo de espera de casi 3 semanas para la entrega (bueno, viene desde muy lejos hacia Ecuador)
  • Cable USB bastante corto, y si usas una PC de escritorio, quizás necesites un cable más largo
  • Empaque de transporte aceptable, pero no el 100% adecuado.

 

Valoración: 100/100

Aplicaciones

Con las pruebas que he realizado, he llegado a montar aplicaciones tan simples como un voltímetro digital usando una pantalla LCD, hasta reemplazar toda la electrónica de un transmisor de radio control básico, para convertirlo en un transmisor completamente programable. Las aplicaciones provienen de nuestras necesidades, así que a darle un buen uso.

Un ejemplo que lo tengo en video, es mi módulo de transmisor para radio control, donde el Freaduino Uno, se encarga de la lectura de los potenciómetros de las palancas de mando, el procesamiento de los datos, la visualización en una pantalla LCD y el envío de una señal PPM hacia el módulo de radio frecuencia. Les dejo un video con esta aplicación.

Enlaces

Reviviendo al Arduino Nano de un Cortocircuito

Tarde o temprano a todos nos pasa…. un cortocircuito por un descuido (en este caso, un potenciómetro mal conectado en el protoboard), y lastimosamente, despues del click del cortocircuito, el Arduino Nano con el que estaba trabajando dejó de funcionar.

Estando conectado al puerto USB, lo que esperaba es que haya muerto mi hub usb,pero en lugar de eso, el Arduino simplemente dejó de recibir +5V desde el cable USB, lo que nos daba una esperanza.

Efectivamente, conectandolo con una alimentación externa, funcionaba correctamente, así que había que buscar una solución a este problema. Resulta que entre la entrada de +Vusb y Vcc, existe un diodo, que se había abierto.

arduino1

La solución, sencilla, hacer puente en el diodo, para alimentar al AVR directamente desde el puerto. Eliminamos la protección, pero lo que necesitamos es que funcione. A la final, este arduino irá alimentado únicamente desde la entrada externa de poder.

Como vemos en la siguiente imágen, hemos hecho un puente en el diodo, y con esto nuestro Arduino volvió a la vida!

arduino2

Stellaris Launchpad y Energia: Programando un Cortex-M3 fácilmente

Luego de tenerlo algún tiempo empolvándose, decidí darle una prueba al Stellaris Launchpad que compré  (en $5.00) cuando lo lanzaron hace más de 6 meses, y la verdad que el precio de $12.00 actual, sigue siendo una ganga, para toda la potencia de este microcontrolador.

StellarisLaunchPad_estore

Entre los periféricos importantes de este micro, podemos comentar:

  • Reloj principal de 80Mhz y 32khz para modo de bajo consumo
  • 256kb de memoria flash
  • 32kb de memoria ram
  • 2kb de memoria EEPROM
  • Controlador uDMA de 32 bits
  • 2 ADC de 12 bits – 1MSPS
  • Comparadores Analógicos
  • 8 puertos UART
  • 4 puertos SPI
  • Puerto USB Host/Device/OTG
  • 12 Timers
  • 16 Salidas PWM
  • Puertos GPIO
  • Debugger integrado en la tarjeta
  • 2 pulsantes, y 1 led RGB para pruebas

stellaris_perifericos

 

Como vemos, este micro, tiene mucha potencia en ese pequeño paquete, pero tanta potencia tiene un precio. Desarrollar para este micro puede convertirse en un dolor de cabeza, ya que es necesario utilizar Code Composer Studio de TI. Este IDE basado en Eclipse, nos permite programar y depurar al stellaris, pero su gran tamaño (la descarga es de 1GB aproximadamente) y lo lento de Eclipse, puede hacernos despechar de cualquier proyecto pequeño que tengamos.

Afortunadamente, existe el Proyecto Energia, que nos permite programar al Stellaris Launchpad con una interfaz de programación similar a la de nuestro conocido Arduino, y nos brinda facilidad de programación, usando toda la potencia del Stellaris.

Al descargar y abrir Energia, vamos a tener una interfaz idéntica a la del IDE de Arduino, salvo por el color rojo de la misma (Rojo Stellaris XD), y podemos compilar algunos de los ejemplos, como el típico Blink.ino incluido dentro del IDE

stellarisblink

Ahora, vamos a hacer algo más útil. Aprovechando los ADC de alta velocidad, vamos a intentar capturar datos con el ADC a la máxima velocidad posible (tomando en cuenta que lso ADC son de 1MSPS).

Por ventaja para nosotros, Energía trae precompiladas todas las librerías Stellarisware,  que nos brindan rutinas de configuración y acceso a todos los periféricos de nuestro micro. Con estas librerías, programamos un sketch que va a hacer 3 cosas:

  • Habilitar el puerto serial para envío y recepción de datos
  • Capturar datos con el ADC, usando interrupciones, iniciando las interrupciones del ADC al recibir un dato desde el puerto serial. Se capturará 2048 datos en ráfaga, sin usar DMA.
  • Generar un timer de 1hz para referencia

Nuestro sketch para realizar esto es el siguiente:

#include "Energia.h"
#include "inc/hw_memmap.h"
#include "inc/hw_types.h"
#include "inc/hw_ints.h"
#include "driverlib/debug.h"
#include "driverlib/interrupt.h"
#include "driverlib/sysctl.h"
#include "driverlib/adc.h"
#include "driverlib/timer.h"

int i=0;
int j=1;
int dato0=0;
int adc[1024];
unsigned char dataReady=0;
unsigned long ulADC0Value[1];
unsigned long time1;
unsigned long time2;
unsigned long ttotal;

void setup() {
  Serial.begin(115200);
  pinMode(RED_LED, OUTPUT);
  pinMode(BLUE_LED, OUTPUT);
  pinMode(GREEN_LED, OUTPUT);

  initADC();  
  initTimer(2);

  Serial.println("Inicio OK. ");
  Serial.print(SysCtlClockGet());
  Serial.println(" hz");

}

void loop() {
  unsigned char serialIn;
  int i;
   digitalWrite(GREEN_LED,1); 

   if (Serial.available() > 0) {
     serialIn=Serial.read();
     ADCIntEnable(ADC0_BASE, 3);
   } 

   if (dataReady!=0) {
     Serial.println("Datos ADC");
     for (i=0;i<=1023;i++) {
         Serial.println(adc[i]);
     }

     dataReady=0;
   }
}

 void Timer0IntHandler()
{

  // Clear the timer interrupt
  TimerIntClear(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
  //leeADC();
  digitalWrite(RED_LED, j&0x01);  
  j++;

}

void ADC0IntHandler() {
   ADCIntClear(ADC0_BASE,3);
   ADCSequenceDataGet(ADC0_BASE, 3, ulADC0Value);
   adc[i]=(int)ulADC0Value[0];  
   i++;
   if (i&0b10000000000) { i=0; ADCIntDisable(ADC0_BASE, 3); dataReady=1;}
   //ADCProcessorTrigger(ADC0_BASE, 3);
   //digitalWrite(RED_LED, i&0x01);
}

void initTimer(unsigned Hz)
{
  SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0);
  //TimerConfigure(TIMER0_BASE, TIMER_CFG_32_BIT_PER);
  TimerConfigure(TIMER0_BASE, TIMER_CFG_PERIODIC);
  unsigned long ulPeriod = (SysCtlClockGet() / Hz) / 2;
  TimerLoadSet(TIMER0_BASE, TIMER_A, ulPeriod -1);
  IntEnable(INT_TIMER0A);
  TimerIntEnable(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
  TimerIntRegister(TIMER0_BASE, TIMER_A, Timer0IntHandler);
  TimerEnable(TIMER0_BASE, TIMER_A);

}

void initADC(void) {
	SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);
	SysCtlADCSpeedSet(SYSCTL_ADCSPEED_1MSPS);
        //SysCtlADCSpeedSet(SYSCTL_ADCSPEED_500KSPS);
	ADCSequenceDisable(ADC0_BASE, 3);
	//ADCSequenceConfigure(ADC0_BASE, 3, ADC_TRIGGER_PROCESSOR, 0);
        ADCSequenceConfigure(ADC0_BASE, 3, ADC_TRIGGER_ALWAYS, 0);
	ADCSequenceStepConfigure(ADC0_BASE, 3, 0, ADC_CTL_CH0 | ADC_CTL_IE | ADC_CTL_END); //Sequencer 3 Step 0: Samples Channel PE3
	//ADCSequenceStepConfigure(ADC0_BASE, 3, 0, ADC_CTL_TS | ADC_CTL_IE | ADC_CTL_END); //Sequencer 3 Step 0: Samples TS
        ADCIntRegister(ADC0_BASE, 3, ADC0IntHandler);
	ADCSequenceEnable(ADC0_BASE, 3);
        ADCIntEnable(ADC0_BASE, 3);
        //ADCProcessorTrigger(ADC0_BASE, 3);
}

Como vemos en el código, tenemos 2 rutinas de inicialización de periféricos, 2 rutinas de interrupción, y las cásicas setup() y loop() del programa principal. Facil no?

Ahora, debemos tener una consideración adicional. El compilador para este procesador Cortex, necesita un archivo llamado startup.gcc (que se encuentra dentro del IDE Energia) que define las subrutinas de interrupción de cada uno de los periféricos. Es por esto, que debemos modificar el nuestro, para que quede algo así:

/*
 * create some overridable default signal handlers
 */
__attribute__((weak)) void UARTIntHandler(void) {}
__attribute__((weak)) void ToneIntHandler(void) {}
__attribute__((weak)) void I2CIntHandler(void) {}
__attribute__((weak)) extern void Timer0IntHandler(void) {}
__attribute__((weak)) extern void ADC0IntHandler(void) {}

y un poco mas abajo

__attribute__ ((section(".isr_vector")))
void (* const g_pfnVectors[])(void) =
{
   (void *)&_estack,                        // The initial stack pointer, 0x20008000 32K
    ResetISR,                               // The reset handler
    NmiSR,                                  // The NMI handler
    FaultISR,                               // The hard fault handler
    IntDefaultHandler,                      // The MPU fault handler
    IntDefaultHandler,                      // The bus fault handler
    IntDefaultHandler,                      // The usage fault handler
    0,                                      // Reserved
    0,                                      // Reserved
    0,                                      // Reserved
    0,                                      // Reserved
    IntDefaultHandler,                      // SVCall handler
    IntDefaultHandler,                      // Debug monitor handler
    0,                                      // Reserved
    IntDefaultHandler,                      // The PendSV handler
    IntDefaultHandler,                      // The SysTick handler
    GPIOAIntHandler,                        // GPIO Port A
    GPIOBIntHandler,                        // GPIO Port B
    GPIOCIntHandler,                        // GPIO Port C
    GPIODIntHandler,                        // GPIO Port D
    GPIOEIntHandler,                        // GPIO Port E
    UARTIntHandler,                         // UART0 Rx and Tx
    UARTIntHandler,                         // UART1 Rx and Tx
    IntDefaultHandler,                      // SSI0 Rx and Tx
    I2CIntHandler,                          // I2C0 Master and Slave
    IntDefaultHandler,                      // PWM Fault
    IntDefaultHandler,                      // PWM Generator 0
    IntDefaultHandler,                      // PWM Generator 1
    IntDefaultHandler,                      // PWM Generator 2
    IntDefaultHandler,                      // Quadrature Encoder 0
    IntDefaultHandler,                      // ADC Sequence 0
    IntDefaultHandler,                      // ADC Sequence 1
    IntDefaultHandler,                      // ADC Sequence 2
    ADC0IntHandler,                      // ADC Sequence 3
    IntDefaultHandler,                      // Watchdog timer
    Timer0IntHandler,                      // Timer 0 subtimer A

podemos ver que el ADC sequece 3, y el Timer 0 tienen aquí definidas sus subrutinas en este archivo. Si quieren descargar el archivo completo, pueden usar este link.

Y que tal funciona? pues midiendo una señal de referencia de 8khz, vemos que muestrea eficientemente a 950Ksps, que es mucho más alto de los 10Khz que se obtiene con el Arduino… hay mejora cierto?

Transmisor de 2.4Ghz con Arduino

Como vieron hace un par de semanas, estuve diseñando un transmisor de radio control de 4 canales, de 2.4Ghz de frecuencia, para actualizar mi transmisor básico (un Hobbyking de 6 canales).

La idea es que el Arduino se encargue de todo lo que concierne a la lectura de los potenciómetros, inversión de la dirección de los servos (en los casos que se requiera), ajuste de máximos y mínimos, y la generación de la señal PPM, que se enviará al módulo de RF original del transmisor donante.

Actualmente, el programa simple que hice, mantiene memoria para 5 modelos (almacenados en la eeprom del microcontrolador), controla la dirección de los servos, y dual rates para cada canal.

El circuito del transmisor es el siguiente:

tx

 

Como podemos observar, el circuito es bastante simple. El arduino va conectado a un shield de LCD+teclado para la visualización y comando de los menus; los 4 potenciómetros son los que van en las palancas de mando, los 2 interruptores son los de Throtle Cut (apaga los motores directamente) y para el Dual Rate, y la señal PPM es generada en el pin 9 del Arduino, desde donde se la conecta al módulo de 2.4Ghz.

El transmisor funciona a la perfección. Hoy hice un pequeño vuelo de prueba, y no hubo interferencias ni pérdidas de señal.

El código fuente, y la librería RC, necesaria para el cálculo y generación de los pulsos PPM, los pueden descargar de los siguientes enlaces:

El código puede ser mejorado, pero para desoxidarme un poco en la programada de microcontroladores, funciona bién.

Les dejo un video de las últimas pruebas, antes del vuelo.