Microhelicopteros! Review de un minihelicóptero de 3.5 canales

La gente de www.tmart.com fué muy amable en enviarme un minihelicóptero de 3.5 canales con control infrarojo, para realizar unas pruebas, así que les comentaré por acá mis experiencias con el mismo.

Hace algún tiempo, llegaron acá al Ecuador una oleada de microhelicópteros, que prometian mucho (facilidad de vuelo y durabilidad), pero la verdad es que no eran ni fáciles de volar, ni eran durables ni baratos. Mucha gente los compró y tuvieron un mal inicio en el hobbie del radio control, ya que estos helicópteros causaban mas frustración que diversión.

Es por esto que le dí una oportunidad a este helicóptero, así que vamos revisandolo.

Primero el empaque. Éste vino empacado de una manera muy profesional, con doble capa de envoltura de burbujas (grandes por fuera, pequeñas por dentro), con lo que se garantiza que el paquete arribará sano y salvo a la puerta de tu casa.

DSC00202

 

 

DSC00203

Por si no abrieron el link del producto (deberían hacerlo ahora), notarán que primero, este tiene un costo bajísimo (USD. $19,99) que incluye en envío gratis, ya sea desde las bodegas de EEUU, o desde la principal en la China. En mi caso el paquete fué enviado desde EEUU, y demoró algo más de 7 días en llegar a Cuenca. Tomen en cuenta que por la característica del artículo, éste debió pasar por aduana, lo que aumentó un pago de $5,00 el momento de la entrega, por gastos aduaneros.

 

Una vez abierto el paquete, lo primero que me gustó fué la calidad de la caja del mismo (está genial para ponerlo sobre una repisa, como adorno). El helicóptero y su control remoto vienen en una caja de acrílico transparente, que lo hace facil y seguro de transportar, por si quieres llevarlo fuera de casa

DSC00204

 

Para sacar al helicóptero de su caja, necesitarás un destornillador estrella pequeño, ya que el mismo tiene atornillada una base a su tren de aterrizaje. Esta medida me parece excelente porque lo asegura a la caja durante el viaje, evitando sorpresas en la entrega. Además, en la parte inferior de la caja, existe un pequeño compartimento (también asegurado con tornillos) que contiene el cable de carga USB, y una hélice trasera de repuesto (muy conveniente, para no truncar nuestros primeros vuelos experimentales)

DSC00206

 

DSC00208

DSC00209

 

Si algo puedo mencionar, es que el control remoto se ve algo «barato» comparado con el resto del paquete. Es de plástico rojo, y las palancas se las siente un poco débiles. El control tiene los mandos para la velocidad de giro de las hélices, rotación en el eje de la hélice, y para moverse adelante y atrás (throtle, rudder, elevator para los que conocen más de RC) y además, contiene una perilla para calibrar el giro del helicóptero, es decir, para mantenerlo estable en el aire. Aparte de los controles, existe un selector de canal, lo que nos da a pensar que podemos volar hasta 3 helicópteros a la vez, sin tener interferencia. El control remoto trabaja con luz infraroja, así que el rango de control es de máximo 5m en línea de vista, lo que es suficiente para volar en interiores. El transmisor usa 6 baterías AA, y además tiene un cable que permite cargar el helicóptero directo desde el control.

DSC00213

DSC00214

 

El helicóptero como tal, no tiene nada que ver con la calidad del control remoto. Éste está fabricado en aluminio y plástico, Excelente calidad de fabricación! Contiene 3 motores, la batería y toda la circuitería de control, incluido in giroscopio, que ayuda a estabilizarlo en el aire, facilitando su control

DSC00216

 

DSC00211

 

DSC00212

 

La batería incluida es de 150mah, lo que nos dá un tiempo de vuelo de unos 5 mins. Usando el cargador USB, demora de 10 a 12 mins en recargarse, lo que me gusta, porque he visto otros que necesitan casi 1 hora para recargar, y dan menos tiempo de vuelo.

Ahora la pregunta del millón: como vuela? Pues les digo que son los $19,99 que mejor pueden invertir en un helicóptero de este tipo. Inicialmente pensé «esto se va a estrellar y romper en el primer despegue» pero no! El helicóptero es super estable, los mandos no tienen una respuesta tan rápida, lo que ayuda en el control para los principiantes, y lo más importante, es muy muy resistente a los golpes. El truco es que, cuando veas tu helicoptero por estrellar, corta la potencia de las helices. Con eso caerá pero te asegurarás de no romper ningún engrane interno.

Resumiendo, y haciendo una comparativa, tenemos que:

A favor:

  • Precio imbatible (por $20 con todo incluido, que puede salir mal)
  • Excelente empaque, quedarías de película regalando uno
  • Listo para volar. Solo agrega baterías al control remoto y carga el helicóptero
  • Muy fácil de volar. El giroscopio hace casi todo el trabajo de estabilización, y el helicóptero como tal viene muy bien balanceado
  • Se carga desde el control remoto o desde el puerto USB
  • Se carga en 10 mins y vuela por 5 mins. Mucha diversión y poca espera
  • Ideal para la casa  u oficina. Saca al geek que hay en tí

 

En contra:

  • Necesitas 6 baterias AA
  • Tiempo de entrega de 1 semana cuando envían desde EEUU, desde China el tiempo puede subir hasta 3 semanas
  • El control remoto infrarojo puede causar interferencias (nunca lo uses cerca del control remoto de la TV)
  • Corto alcance (5m), aunque suficiente para interiores
  • Casi imposible de volar en exteriores. Incluso soplando sobre el se desestabiliza por su escaso peso.

Si desean echarle un ojo y comprarlo, este es el enlace http://www.tmart.com/3.5-Channel-Infrared-R-C-Mini-Helicopter-with-Gyro-Red_p136571.html . La compra es segura y el pago con paypal no presenta ningún problema. El momento del envío ellos envían un código de tracking del paquete, para que todo sea legal.

Y por si les queda la duda, les dejo un video de las pruebas de vuelo (ojo al final con los accidentes). Realmente es algo que puedo recomendar comprar a cualquiera que quiera probar iniciarse en el mundo de los helicópteros. La verdad es que con éstos, hay que empezar desde abajo 🙂

 

[HTML1]

 

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.

[HTML1]

 

Cliente de Bittorrent para el Raspberry Pi

Y bueno, mi Raspberry Pi pasa todo el día conectado monitoreando la casa, y como durante el día no hay nadie, la conexión de internet pasa completamente desocupada….. algo realmente malo.

Para aprovechar un poco más nuestra conexión perezosa, instalé Transmission, que es un cliente de Bittorrent que corre como un demonio en Linux; dado que el Raspberry Pi consume prácticamente nada de energía al estar conectado, resulta bastante práctico para tenerlo descargando cosas durante el día.

Para instalar Transmission, debemos ejecutar los siguientes comandos desde el terminal de nuestro Pi:

sudo apt-get install transmission-daemon
sudo apt-get install transmission-common
sudo apt-get install transmission-cli

Si no hay ningún problema en la descarga se instalarán los paquetes necesarios, y arrancará el demonio de transmission. Antes de empezar a usarlo, debemos editar un par de detalles en su archivo de configuración. Para esto, detenemos el servicio con el siguiente comando:

sudo service transmission-daemon stop

A continuación editamos el archivo /etc/transmission-daemos/settings.json (sudo nano /etc/transmission-daemos/settings.json) y modificamos las siguientes líneas, con los datos que vayamos a usar según nuestro caso (para las rutas de archivo y las IPS, son las que tengo creadas en mi PI):

"download-dir": "/home/pi/transmission", 
"incomplete-dir": "/home/pi/transmission/incompleto",
"rpc-whitelist": "127.0.0.1,192.168.1.100",
"rpc-whitelist-enabled": false,

Además, para dar acceso via navegador, es necesario que modifiquemos las líneas del nombre de usuario y contraseña del mismo archivo:

"rpc-password": "su_contrasena",
"rpc-username": "su_usuario",

La contraseña acá la colocamos sin encriptar. El momento de reiniciar el demonio se encriptará automáticamente. Para reiniciar el servicio, basta con el comando:

sudo service transmission-daemon start

y Voilá! tenemos nuestro cliente de bittorrent conectado 24/7, que lo podemos monitorear desde nuestro navegador, con la IP de nuestro Raspberry, y el puerto 9091

torrent

Felices descargas 🙂

pd. Si desean acceso externo (por ejm. para colocar descargas desde la oficina) basta con abrir el puerto 9091 en su router, y en lo posible, darle un dominio virtual, como lo indiqué en el post de cómo configurar no-ip para el raspberry.

Transmisor RC con Arduino – Actualización

Este fin de semana que tuve un poco de tiempo libre, pude depurar un poco el código del arduino, y conectarlo al módulo de radiofrecuencia del transmisor que tengo para actualizar.

Estos son los resultados

[HTML1]

El transmisor funciona correctamente, así como las memorias de los modelos (por ahora, en RAM), el dual rate, y la reversa de servos. Voy a programar la grabación en memoria flash de los valores, y una función exponencial básica, y estaremos listos.

Arduino + Radiocontrol = Diversión !!

Bueno, como todos saben, soy un «poquitín» fan del Radio Control (fan si, pero exageradamente fan no…. este es un hobby que puede quebrar bancos si no se lo lleva con mesura).

En lo que respecta a aviones de control remoto, soy bastante «cheap» (con los carros, es otra historia jeje). Hace un par de años, compré un radio de 6 canales en hobbyking, un manojo de servos, motores y baterías, todo por $100 incluido el envío. Con eso me ha bastado para, a través del tiempo y de las pruebas, armar un par de avioncitos decentes de espumaflex (si, la misma de los platos desechables) que han resistido el abuso y el aprendizaje del vuelo por radio control.

Pero este post no es sobre aviones o carros, sino sobre arduinos y transmisores. Yo uso este transmisor de hobbyking.

HK-T6XV2-M1(2)

que la verdad, para el precio, dudo que se pueda conseguir algo mejor. 6 canales, 2.4Ghz, 1 receptor super liviano; para iniciarse, los $50 mejor invertidos jejeje. El único pero de este radio es su relativa falta de programación. Digo relativa, porque usando la aplicación para PC y el cable de conexión USB, podemos programarlo como queramos (incluso tiene un modo para helicóptero CCPM), pero cuando tienes 2 aviones, con configuraciones de servo diferentes, se vuelve algo «engorroso» llevar la laptop a todo lado para programar el radio.

Es aquí donde entra el Arduino, y más específicamente un clon de Arduino, el Freaduino Uno, que puede ser comprado en internet por unos cuantos dolares (22,80 para ser exactos). La idea es que el arduino, reemplace todo el CPU del radio transmisor, y nos permita programarlo a nuestra manera.

Actualmente, el arduino tendrá las siguientes tareas:

  1. Leer la posicion de las palancas usando sus ADC
  2. Tomar dichos valores y procesarlos según los parámetros seleccionados (direccion de servos, ajustes de punto máximo, exponenciales, etc)
  3. Generar una señal PPM en función de los valores procesados
  4. Hacer todo esto, mientras se comandan los parámetros de control desde un LCD con un teclado

Realmente, luego de haber programado por muchos años en el micro 8051, y muchas variedades de Pics de Microchip, me doy cuenta el por qué el arduino ha pegado tanto en los hobbistas de electrónica. Al no necesitar programador adicional, se vuelve una herramienta plug-and-play para cualquier proyecto electrónico; su interfaz de programación es fácil de usar, y existen librerias prediseñadas casi para todo…… el sueño de todo estudiante de electrónica. Volviendo al tema, el uso del arduino en este proyecto, resultó una grán ventaja, ya que primero, las librerías para manejo de los ADC, LCD y teclado están ya listas, solo de incluirlas y usar.

Luego de unas pocas líneas de código, pude generar un menú de opciones, para seleccionar los valores de la dirección del servo, y los dual rates para cada canal. esto lo podemos ver en las siguientes imágenes.

2013-01-26_10-13-53_126

 

2013-01-26_10-14-13_468

 

Realmente, uno se ahorra tiempo y plata, tomando en cuenta que acá un PIC 18F4550 bordea los $10 sin los componentes adicionales para hacerlo funcionar, creo que facil el arduino que he comprado resulta más barato que la placa de comando de servos que diseñé hace algun tiempo, basada en Pic.

Hasta ahora todo va bien, tenemos el ADC y algunas opciones básicas funcionando en el nuevo CPU de nuestro radio, pero viene la parte fuerte, tomar los valores procesados y convertirlos en una señal PPM, la cual será alimentada al módulo de 2.4Ghz del radio, para transmitirla al aire.

Luego de algunas pruebas, he logrado generar dicha señal, y va bastante bién. El siguiente paso es montar todo en la caja del radio y probar si realmente funciona. Les dejo una imágen de mi pantalla (estoy usando un osciloscopio de tarjeta de sonido para verificar las señales) para que observen la señal generada a la salida del nuevo CPU.

Apenas existan más avances, se los haré saber 😉

2013-03-09_23-02-09_575

 

 

Dios, el universo, y todo lo demás

Si tienen una horita libre (un lujo bastante escaso en estos tiempos), les invito a ver este video, donde Carl Sagan,
Stephen Hawking y Arthur C. Clarke, discuten los orígenes del universo, la creación, los agujeros negros, y la vida extraterrestre. Muy interesante discusión, y muy interesante el video.

Se los recomiendo

[HTML1]

Controlador para servomotores USB, con entradas y salidas digitales

Para mi proyecto de tesis (recuerdan la Plataforma Stewart?), realizado con mi compañera Natalia Gonzalez, tuvimos la necesidad de diseñar una tarjeta controladora de servos, que nos permita controlar simultáneamente hasta 8 servos, con entradas y salidas digitales adicionales, y controlado por puerto USB. Para esto, hemos utilizado un microcontrolador PIC 18F4550, que tiene el hardware para conexión USB integrado dentro del microcontrolador, y dicho puerto USB puede ser configurado como un puerto serial emulado, lo que facilita muchísimo la interfaz con el PC, al no necesitar programar drivers específicos para nuestra tarjeta electrónica.

Como conocemos, cada servomotor necesita un pulso, cuyo ancho debe variar entre 1.25 y 1.75ms (siendo 1.5ms el ancho de pulso necesario para llegar a la posición central), que debe ser refrescado cada 20ms para mantener su posición. Controlar un servo por medio de interrupciones no presenta mayor inconveniente, pero para controlar 8 simultáneos, hay que poner un poco a trabajar el cerebro.

Usando una sola interrupción para controlar los 8 servomotores, lo que debemos hacer es multiplexar al timer 0, de tal manera, que aproximadamente cada 4ms, se dispara una nueva interrupción, que indicará que salida de servo se debe activar, y el tiempo que estará activa, de acuerdo a los valores de posición que asignemos a cada servo.

Los datos de la posición de cada servo, se los enviará via comunicación serial por el puerto USB, para esto se ha definido un pequeño protocolo de comunicación con la tarjeta electrónica, que responde a los siguientes comandos:

// comandos:
// 's' muestra ok para verificar conexion
// 'd'x escribe dato de 8 bits. espera dato de salida
// 'q'x activa salida x (0-7)
// 'w'x desactiva salida x (0-7)
// 'r' devuelve un dato de 8 bits de entrada del puerto D
// 'p'xy asigna al servo x (caracter entre 0 y 7) el valor y (caracter con un código ASCII entre 0 y 255)

Con estos comandos, además de poder controlamos los servos, tenemos la posibilidad de usar las entradas y salidas digitales programadas para la tarjeta.

El esquema del circuito es bastante sencillo, tal como lo mostramos a continuación:

Algo a tomar en cuenta en el diseño de la tarjeta electrónica, es la alimentación del circuito. El microcontrolador, puede ser alimentado directamente con los +5V del puerto USB, pero los servos, dependiendo del tipo, pueden consumir mucha mas corriente de los 1000mA que puede entregar el puerto USB de un computador personal. Es por esto, que tenemos 2 lineas de alimentación: Vdd que alimenta el microcontrolador (y está enlazado a +5V del puerto USB) y V+ que es una alimentación externa para los servos (que incluso, para darles mayor torque, puede subir hasta 6V, o más, si usamos servos HV).

Para el diseño del PCB, se utilizó una placa de doble lado, con un diseño bastante sencillo. El diseño como tal no es crítico, ya que se manejan señales de baja frecuencia.

El software que corre en el microcontrolador, fué realizado en C, usando el compilador propio de Microchip. El código fuente, con todas sus librerías, puede ser descargado en este enlace y el link del driver para el puerto serie (en sí es un archivo inf, con las definiciones del puerto USB) puede ser descargado aquí.

Podemos decir que se puede mejorar un poco el software (podrían agregarse entradas analógicas únicamente cambiando el código fuente, sin modificar el hardware), pero para nuestro proyecto, esta tarjeta electrónica funcionó perfectamente.

Les dejo un video del robot, que utiliza servos 6 estandard, cuyo control es realizado por la tarjeta electrónica que presentamos acá.

[HTML1]

Y el video final de la plataforma (el que fué presentado en la sustentación final de la tesis)

[HTML2]