Die Bot Reise

El salto del 4G al 5G en la comunicación móvil, ¿es realmente necesario?

2017-05-10T01:42:00.000+02:00

¿Qué es el 5G?

Es la quinta generación de tecnología de transmisión de datos móviles, es decir, una mejora o actualización del actual 4G. La tecnología del 5G se encuentra todavía en fase de desarrollo y sin estandarizar. Este nuevo protocolo está siendo desarrollado gracias a la colaboración de varias empresas del sector de las telecomunicaciones, entre ellas Huawei, estando previsto que vea la luz en el 2020.

Pero… ¿Por qué necesitamos el 5G?

La pregunta que quizás se puede hacer el usuario final, <<Si yo actualmente casi ni utilizo el 4G, ¿para qué necesito el 5G?>> El 5G tendrá más aplicaciones y no únicamente está pensado para que los usuarios puedan ver vídeos en Facebook en el móvil con más velocidad, aunque también serviría para esto. El usuario se beneficiaría directa o indirectamente tras la implantación de la tecnología 5G a corto plazo.

Las principales mejoras del 5G son:

El número de conexiones por emisor. Pasando de miles en el 4G a millones en el 5G de usuarios por antena.
La latencia bajaría desde los 100ms (3G), 50 ms (4G) a 1 ms para el 5G.
Velocidad de descarga pico se incrementa desde 150 Mbits/s (4G) hasta 10Gbits/s.

El incremento de conexiones por emisor soluciona el problema de la aglomeración de gente en un espacio concreto para eventos como por ejemplo un evento deportivo, fiestas populares o un concierto grande. En estos casos el sistema no está dimensionado para tanta gente, porque normalmente esto no pasa. En estas situaciones hay problemas de red, incluso pérdida de conexión. Con el 5G una antena podría dar servicio a mucha más gente en caso de ser necesario.

¿Qué campos de aplicación tendrá el 5G?

Muchos campos de aplicación como en los transportes públicos, aplicaciones médicas, almacenamiento en la nube o servicios en streaming, red eléctrica inteligente o smart grids, industria 4.0 en otros, pero me gustaría destacar tres aplicaciones que tendrán especial relevancia al usuario final:

El internet de las cosas (IoT, Internet of Things)
Internet desde receptores en movimiento. Garantizar una conexión rápida y sin cortes desde, por ejemplo, coches, trenes o aviones.
En sistemas interactivos de realidad virtual y realidad aumentada.

¿Qué futuro tiene el 5G con la realidad virtual?

La realidad virtual se está haciendo un hueco en el presente y cada vez tendrá más presencia en el futuro. En los últimos años ha aparecido un nuevo concepto: la realidad virtual interactiva, en la que dos o más usuarios serán capaces de interactuar como si estuviesen en el mismo lugar. Para un buen funcionamiento de un sistema de realidad virtual interactiva u online, es de suma importancia no sólo una velocidad rápida de transmisión de datos, sino que también la latencia, que jugará un papel importante en este tipo de aplicaciones.

La latencia se define como el tiempo que pasa desde que mandamos una petición y una respuesta del servidor es recibida. En realidad virtual la latencia es indispensable, ya que si pasa demasiado tiempo entre que ejecutamos una orden (nos movemos) y esta se convierte en realidad (lo vemos en las gafas o pantalla), no sólo bajará significativamente el grado de realismo, sino que será más fácil que nos equivoquemos en nuestra tarea. A nuestro cerebro le es difícil gestionar ese retardo provocado por la red. ¿Con qué velocidad tendría que responder un entorno virtual para que una persona no notase la diferencia con un entorno real? Algunas estimaciones apuntan a que se necesitan alrededor de 10 ms para estímulos visuales y unos 100 ms para estímulos acústicos.

Los mareos en realidad virtual son un problema de la tecnología de hoy, que se intentará evitar en el mañana. Los mareos se producen principalmente cuando la persona realiza un movimiento y el sistema no cambia de imagen lo suficientemente rápido, quedando de esta manera un desfase entre lo que vemos en la pantalla y lo que el cerebro espera ver. Este desfase o lag se le conoce como motion-to-photon y debe ser inferior en todo caso a los 20 ms para evitar esa sensación de mareo, aunque esta medida depende mucho de cada persona.

Para crear sistemas de realidad virtual interactivos con un buen grado de realismo, la velocidad de respuesta ha de ser en todo caso inferior a 10ms. Aquí entra en el juego el papel del 5G reduciendo el tiempo de latencia hasta 1 ms, en vez de los 50ms del 4G, aumentando de manera notable la velocidad de reacción.

¿Qué papel juega Austria en el desarrollo e implantación del 5G?

Austria quiere estar entre los tres países más digitalizados de Europa y en el top 10 del mundo. Para ello quiere convertirse en un referente en 5G siendo pionera en implantación de esta nueva tecnología. Según un comunicado del gobierno en el consejo de ministros en diciembre de 2016, Austria pretende el año 2020 contar con redes 5G operativas al menos en todas las capitales de provincia.

Huawei está invirtiendo fuertemente en el desarrollo de esta tecnología que mejorará las comunicaciones. Para ello estiman en Huawei una inversión mínima de unos 600 millones de dólares en los próximos 5 años. La conocida marca china comenzó a invertir en 2009 en el 5G y ya presentó en el Mobile World Congress de 2011 y 2012 un prototipo líder del sector con unas velocidades de descarga de hasta 50Gbps.

Huawei, en colaboración con T-Mobile Austria, lanzarán en 2018 una nueva red de transmisión conocida como “LTE advanced pro” también nombrada 4.5G, la antecesora de lo que será el 5G. Dos años después, allá en el 2020, deberá salir al mercado el esperado 5G.

Tutorial: Cómo Programar y Simular la FPGA de ZYBO en VDHL con Vivado

2017-04-06T18:26:00.000+02:00

En este tutorial explicaré como empezar un proyecto en Vivado para crear sencillos programas en la FPGA usando la placa ZYBO de Digilent. (aunque analogamente se puede usar para otros tarjetas de desarrollo como ZedBoard o otras basadas en Zynq).
La tarjeta ZYBO, y todos los Soc (System on Chip) cuentan con una parte FPGA y otra de Procesador. El FPGA se considera programar "Hardware" y el porcesador es un ARM de 2 núcleos que se programa con software, como cualquier otro microprocesador.
Al final veremos como simular nuestro código VHDL con la herramienta Vivado.

Empezamos creando un nuevo proyecto seleccionando la placa Zybo como 'target board'

Selecciona en "boards" Zybo. Por defecto vivado no cuenta con el archivo de definicion "Definition file" de todas las tarjetas. para añadir la Zybo (o ZedBoard) descarga aquí los archivos de Digilent e introdúcelos en el directorio de instalación de Vivado. Esta carpeta se encuentra normalmente, y en mi caso, en C:\Xilinx\Vivado\2016.2\data\boards\board_files pero puede variar en función de dónde hayas instalado Vivado.

Crea un nuevo diagrama de bloques y ábrelo:

Una vez abierto el diagrama de bloques podrás incluir tus IPs (Intelectual Property). Un IP es una función que puede ser creada por tí mismo o de una librería. Ahora incluye el bloque "ZYNQ7_Processing_system".

Puedes clickear en el "run processor system". Esto crea automáticamente

Doble click en el bloque ZYNQ para entrar en el menú de propiedades del IP. Esto funciona con todos los bloques.

En este caso no vamos a usar el bus AXI, por lo que podemos desseleccionar la casilla.

Para alimentar nuestro circuito FPGA con una señal de reloj, usaremos la señal procedente del Processor System. Este reloj se puede configurar, entre 0 y 250MHz, en las propiedades del bloque de ZYNQ.

Para el caso que quieras usar una frequencia de reloj mayor, (ZYBO admite en la FPGA hasta 400 MHz) deberás añadir un bloque llamado "clock wizard" para generar la frecuencia necesaria hasta 400 MHz.

[FOTO clock Wizard]

Ahora añadimos una nueva fuente "Add source" para crear nuestro código VHDL:

Ahora te saldrá la opción de configurar el módulo del VHDL, esto se puede hacer por código en el archivo. Puedes añadir las entradas y salidas del modulo, aunque yo prefiero no utilizar el editor y escribir directamente después en VHDL. Ahora configuramos una señal clk como entrada y una pwm como salida:

Hemos creado un archivo VHDL como fuente, 'source code'. Este ahora lo insertamos en nuestro diagrama de bloques, para ello hacemos doble click y seleccionamos "add module"

seleccionamos el módulo previamente creado:

Y nos quedará el diagrama de bloques de la siguiente manera:

Ya podemos rutear la señal del reloj del PS (Processing System) con nuestra entrada "clk". La salida "pwm" debemos conectarla a un pin de salida, esto se hace haciendo click derecho en el pin pwm y seleccionando "make external"

Así queda hasta ahora el diagrama de bloques:

Para modificar el código de nuestro bloque lo seleccionamos y pulsamos F7. Nos encontraremos con el archivo VHDL de la siguiente manera:

Añadir el código necesario para el PWM:

Ahora debemos empezar la simulación, para testear que todo funciona.

Para empezar la simulación creamos un nuevo diagrama de bloques, para hacer un banco de pruebas y probar las funcionalidades de nuestro bloque.

Hacemos click en "create Block Design" y lo renombramos como testbench:

Si nos fijamos en la ventana "sources" de Vivado, está la carpeta "Design Sources" y "Simulation Sources". El contenido de la carpeta Design se usará luego para generar los archivos necesarios para cargarlos en la tarjeta. Los archivos de Simulation se usarán sólo en el entorno de simulación y serán obviados en los pasos posteriores. Ahora seleccionamos qué archivos deben ser únicamente simulados y cuáles deben ser compilados.

Haciendo click derecho sobre el diagrama de bloques podemos ir a "Set used in..."

Nuestro banco de pruebas o testbench ha de tener la siguientes propiedades:

Y para nuestro diseño o programa para sintetizar, implementar y cargar en la tarjeta ZYBO ha de ser:

En el diagrama de bloques para la simulación añadimos el bloque "Simulation Clock Generator". Este bloque nos generará un reloj para las simulaciones.

A continuación añadimos el módulo previamente creado PWM2, conectamos la señal de reloj y creamos el pin externo para la salida pwm.

El siguiente paso será crear un envoltorio o 'wrap' para los diagramas de bloques:

Como norma general hay que refrescar lo módulos que no están actualizados. En este caso tendremos un error si no actualizamos todos los módulos. Para ello hacemos click en "refresh modules" y posteriormente creamos el wrap de ambos diagramas.

nuestra jerarquía quedaría de la forma:

En la opciones de simulación hemos de comprobar que el 'top module' es nuestro diagrama testbench.

Una vez configurado, empezamos la simulación:

Tras pulsar "Run behavioral Simulation" se debe abrir la siguiente ventana:

Para añadir señales a nuestro diagrama de ondas, simplemente buscamos los bloques previamente instanciados en la parte izquierda y arrastramos hasta el diagrama. Después ejecutamos la simulación para actualizar los valores añadidos.

Reajustando el zoom configurando la señal counter como analógica para una mejor visualización... obtenemos algo parecido a esto:

Sin entrar en detalles, la simulación comprobamos que todo funciona como habíamos diseñado, en caso contrario habría que volver al código VHDL, reescribir y volver a simular.

Ahora suponemos que la simulación es correcta. El siguiente paso es comprobar que nuestro design_1 está actualizado. Los siguientes pasos serán:

Validar el diseño
Síntesis
Configuración de los pines de entrada/salida.
Implementación
Generar Bitstream

Para validar el diseño (F6) oclick en el símbolo de la siguiente imagen:

Iniciar Síntesis:

Cuando la síntesis termina, debemos indicarle a Vivado que pines queremos utilizar para la salida del PWM en este caso. Este paso deberemos realizarlo únicamente la primera vez. En el caso en que cambiemos algo en nuestro diseño y debamos sintetizar otra vez, podemos realizar la implementación directamente, ya que los pines quedarán guardados. Por tanto la segunda vez nos da la opción (si ha terminado sin errores) de ejecutar la implementación.

Para configurar los pines cliqueamos en "open synthesized Design"

Para elegir el pin, abrimos el esquemático de la tarjeta Zybo. En la primera página encontramos los diferentes conectores, debemos elegir un pin. Algunos pines tienen una resistencia en serie de 200 Ohm como medida de seguridad para limitar la corriente. Para un PWM con una respuesta rápida, necesitamos un puerto que no tenga las resistencias de seguridad, por ejemplo el puerto JC, JB o el JD. El conector MIO PMOD es un puerto especial que va directamente al procesador, y no pasa por la FPGA.

En mi caso eslegí el JC1

Que buscando en la página 10 encontramos a que pin está conectado. En este caso V15.

Volvemos a Vivado y buscamos el pin V15 en la lista:

En el campo "Port" seleccionamos nuestra señal de salida pwm. En el "I/O Standart" LCVMOS33

Ahora ya podemos iniciar la implementación. Pero antes Vivado nos preguntará para guardar la configuración de los pines. Esto se guarda en un archivo llamado 'constraints' . A este archivo le nombraremos "my_pins" por ejemplo.

Este archivo "constraints" puede ser modificado posteriormente abriéndolo desde los archivos del proyecto en la carpeta Constraints. De hecho, se podría modificar la configuración de los pines únicamente modificando este archivo.

A continuación iniciamos la implementación, y si todo finaliza sin errores generaremos el Bitstream después. File>> Export>> Export Hardware

Importante incluir el bitstream al exportar el hardware.

A continuación ejecutaremos SDK. SDK es un compilador para programar el procesor ARM. En nuestro caso cargaremos una aplicación vacía, para encender el reloj en el sistema. Para ello click en File>> Lauch SDK

Vivado nos dará la opción para elegir carpetas. Elegimos la opción por defecto, <Local project>.

SDK

Una vez abierto elprograma, seleccionamos File>> New >> Board Support Package

Dejamos la configuración como está y simplemente click en Finish para crear el board_support_package.

En el siguiente panel de configuración tampoco cambiaremos nada, click en OK.

Ahora crea un nuevo projecto vacío:

File >> New >> Application Project

Nombra el proyecto como quieras, en mi caso "Empty_project" y presiona "Next".

Abre el proyecto creado e incluye un loop infinito:

He modificado el código para que escriba por pantalla periódicamente un mensaje. Aunque realmente este paso no es necesario

int main()
{
    init_platform();
while(1){
 int i;
 for(i = 0;i<0XFFFFFF;i++); //Delay
    print("empty project \n\r");
}
    cleanup_platform();
    return 0;
}

Ahora programa la FPGA haciendo click en el icono o en Xilix Tools>> Program FPGA

Confirma que el Bitstream sea el correcto, es decir, el creado y exportado anteriormente.

Una vez programada la FPGA cargamos el software en el procesador ARM. Para ello seleccionamos nuestro proyecto con click derecho >> Debug as.. >> 4.Launch on Hardware (GDB)

Si quieres ver el texto en la pantalla basta con seleccionar

En la etiqueta de STDIO, seleccionar "Connect STDIO to Console" y elige el puerto al que tengas conectado la ZYBO, en mi caso el COM4. Un pequeño truco para ver en que puerto está tu tarjeta conectada es: En el administrador de dispositivos de windows (Device Manager), en la pestaña de COM puedes ver fácilmente conectando y desconectando el USB cuál de los COMs aparece y desaparece. La velocidad de transmisión (Baud rate es 115200).

Con debuggear una vez el código, o ejecutarlo, el reloj de procesador empezará a correr y por tanto nuestro programa en la FPGA.

Tutorial ZYBO-Linux (VI): Ejemplo de I2C con el sensor luminosidad TSL2561 de Adrafruit

2017-03-22T01:07:00.000+01:00

Esta es una continuación de la serie de tutoriales para ZYBO usando Linux.

En este ejemplo se muestra como leer un sensor I2C conectado a ZYBO (de Digilent) desde Linux. El sensor es en este caso el sensor de luminosidad TSL2561de Adrafruit.

Sensor de luminosidad I2C TSL2561

Los detalles de uso de este sensor se pueden leer en el datasheet, aunque resumiendo se han de seguir los siguientes pasos:

Mandar comando de encender 0x80, 0x03
Configurar el tiempo de integración a 13.7ms 0x81, 0x00
Mandar los comandos de lectura para ambos canales. ch0 (0x8c,0x8d) y ch1(0x8d,0x8f)
Convertir a Lux usando la función dada en el datasheet.

Los pines para el I2C son los del PS i2c0: JF1 scl, sca JF2

Una vez conectada la ZYBO por el terminal (ver tutorial (III)) únicamente tendremos que cambiar el software. Para esto abrimos un nuevo archivo de texto e introducimos el siguiente código:

#include <linux/i2c-dev.h>
#include <linux/i2c.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <errno.h>
#include "lux-calculation.c"

/* TODO addapt the i2c slave address to your sensor */
#define I2C_ADDRESS 0x39

/* TODO driver path to the i2c */
static char *i2c = "/dev/i2c-0";
static int i2c_handler;

int i2c_write(int file, char *buf, size_t len)
{
    if (write(file, buf, len) < 0) {
        /* ERROR HANDLING: i2c transaction failed */
        printf("Failed to write from the i2c bus: %s\n", strerror(errno));
        return errno;
    } else {
        return 0;
    }
}

int i2c_read(int file, char *buf, size_t len)
{
    if (read(file,buf,len) < 0) {
        /* ERROR HANDLING: i2c transaction failed */
        printf("Failed to read from the i2c bus: %s\n", strerror(errno));
        return errno;
    } else {
        return 0;
    }
}

double ReadTCusingADC(void)
{
 unsigned char NullCmd = 0x00;
 double ADCoutput = 0;
    char buffer[7] = "";

     
   

    char read_channel[] = {0x8c, 0x8d};
    i2c_write(i2c_handler, read_channel, 2);
    memset(buffer, sizeof(buffer), '\0');
    usleep(2000);

    if (i2c_read(i2c_handler, buffer, 3) < 0) {
        /* ERROR HANDLING: you can check errno to see what went wrong */
        perror("Failed to read");
        exit(1);
    }

 int Ch0 = buffer[0] + 0xFF*buffer[1];
 //printf ("channel0 %d   ", Ch0); //For debugging


 i2c_write(i2c_handler, power_sequence, 2);

    char read_channel2[] = {0x8e, 0x8f};
    i2c_write(i2c_handler, read_channel2, 2);
    memset(buffer, sizeof(buffer), '\0');
    usleep(2000);

    if (i2c_read(i2c_handler, buffer, 3) < 0) {
        /* ERROR HANDLING: you can check errno to see what went wrong */
        perror("Failed to read");
        exit(1);
    }

 int Ch1 = buffer[0] + 0xFF*buffer[1];
   //printf("channel0 %d \n",Ch1); //For debugging

 ADCoutput = CalculateLux(0, 0,Ch0, Ch1, 0 );

 return ADCoutput;
}


int sensor_powerOn(){
 char power_sequence[] = {0x80, 0x03};
 i2c_write(i2c_handler, power_sequence, 2);
 char time_sequence[] = {0x81, 0x00};
 i2c_write(i2c_handler, time_sequence, 2);
 
return 0;
}

int main (void)
{
    /* open device on /dev/i2c-x */
    i2c_handler = open(i2c, O_RDWR);

    if ((i2c_handler = open(i2c, O_RDWR)) < 0) {
        /* ERROR HANDLING: you can check errno to see what went wrong */
        perror("Failed to open the i2c bus");
        exit(1);
    }
    
if (ioctl(i2c_handler, I2C_SLAVE, I2C_ADDRESS) < 0) {
        printf("Failed to acquire bus access and/or talk to slave.\n");
        /* ERROR HANDLING; you can check errno to see what went wrong */
        exit(1);
    }
sensor_powerOn();
printf("sensor_init\n");
 /* TODO: addapt the ReadTCusingADC function to the Lux sensor */
    int i;
    double result;
 
    for (i = 0; i < 150; i++) {
        result = ReadTCusingADC();
        printf("%f\n", result);
        sleep(1);
    }

    /* close connection and return */
    close(i2c_handler);
    return 0;
}

Para compilar este código se necesita el archivo lux-calculation.c dado por el fabricante en el datasheet, que puede descargarse aquí.

tutorial ZYBO-Linux(III): Connecto to Zybo Board, usar los periféricos. Prender un led en dispositivos Zynq

2017-03-21T00:17:00.003+01:00

Esta es la tercera parte del tutorial ZYBO-Linux para arrancar Linux desde la placa de desarrollo ZYBO de Digilent y crear pequeñas aplicaciones. Este tutorial consta de varias partes:

ZYBO-Linux(I): Escribir la imagen de Linux-Debian en una SD
ZYBO-Linux(II): Instalar o arrancar Linux-Ubuntu PC
ZYBO-Linux(III): Conectar con la ZYBO a través del terminal, y usar los periféricos. Ejemplo de prender un led
ZYBO-Linux(IV): Aplicación para leer el estado de los botones desde Linux

A continuación describiré los pasos para iniciar Linux en la ZYBO por una SD y comunicarse por Ethernet con la computadora. Después usaremos los periféricos de la placa como un led o un botón con sencillos programas.

0- Tener creada una SD con la imagen de Linux-Debian hecho en el paso I y cambiar el Jumper JP5 a la posición SD.

1-Conectar la ZYBO a través de Ethernet al ordenador. Si tu ordenador carece de puerto Ethernet necesitarás un adaptador USB.

adaptador USB-Ethernet

2- Configurar la conexión de red en la configuración de red y seleccionar Ethernet.

Introducir las siguientes direcciones de red en la configuración de IPv4 e IPv6:

IPv4

Ignorar la Ipv6

IPv6

3- Abrir el terminal en una computadora con linux (Debian/Ubuntu, etc) y conectar via ssh (secure shell) con la placa. Para ello escribiremos el siguiente comando en la consola:

 ssh root@192.168.1.120

La dirección ip por defecto en la imagen cargada es 192.168.1.120. Esto puede variar con otras imágenes o configuraciones.

4- Para acceder la carpeta de archivos root para ver su contenido e incluir los ficheros c allí abrir una carpeta cualquiera (Nautilus) y hacer click en "connect to Server"

Introducir la IP del puerto de Ethernet anterior como se puede ver en la imagen:

Escribir “sftp://192.168.1.120” y conectar.

A continuación se deberá de abrir una carpeta de este tipo:

5- Crear un nuevo documento de texto en la carpeta raíz de la SD. Abriendo la carpeta y haciendo click derecho, seleccionamos creamos un nuevo archivo y lo renombramos para este ejemplo como blink.c

6- Escribir el código en el archivo de texto. Haciendo doble click sobre el archivo blick.c se abrirá con un bloc de notas vacío. Allí procedemos a insertar nuestro código.

Bloc de notas vacío

El siguiente ejemplo debe encender y apagar el led conectado al puerto MIO7

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
/* Blinking led example
www.dieBotReise.blogspot.com*/
int main ()
{
 int exportfd = open( "/sys/class/gpio/export" , O_WRONLY );
 if( exportfd < 0)
 {
  printf( "Cannot open GPIO to export it \n");
  exit (1);
 }
 write( exportfd ,"913",4);
 close( exportfd );
 printf(" GPIO exported successfully \n " ); 

 /* Get the GPIO value ready to be toggled */
 int valuefd = open( "/sys/class/gpio/gpio913/value" , O_RDWR );


 if ( valuefd < 0){
  printf(" Cannot open GPIO value \n " );
  exit (1);
 }
 printf(" GPIO value opened , now toggling ...\n " );
 /* toggle the GPIO forever , press control + c to stop it */
 while (1)
 {
  int i ;
  for(i=0;i<0xFFFFFF;i++){} 
  write( valuefd , "1" , 2);
  for(i=0;i<0xFFFFFF;i++){}
  write( valuefd , "0" , 2);
 }
}

Debe de quedar de esta manera:

7- Guardar y compilar nuestro programa. Para compilar usando el compilador preinstalado de linux gcc abrimos el terminal y escribimos el comando:

 gcc blink -o blink

Ahora si todo se compiló sin errores se debería mostrar una nueva línea de comando como en la siguiente imagen.

Compilación sin errores

En el caso en que hubiera algún error en el código nos saldría un mensaje explicando el error como el de la figura de abajo:

Compilación con errores

8- Ejecutar el programa. Suponiendo que el programa ha compilado bien con el siguiente comando se ejecutará el código:

 ./blink

Y el led empezará a parpadear. Para parar la aplicación hay que pulsar cntrl+C!!

Tutorial ZYBO Linux (II): Cómo crear una imagen de Ubuntu en un USB desde Windows 7 o windows 10

2017-03-20T23:53:00.000+01:00

Esta es la segunda parte del tutorial ZYBO-Linux donde crearemos una imagen de Linux-Debian en una tarjeta SD para poder arrancar Linux desde la placa de desarrollo ZYBO de Digilent y crear pequeñas aplicaciones. Este tutorial consta de varias partes:

En este tutorial veremos cómo instalar a través de un USB Linux en un ordenador Windows.
Para crear una imagen de Linux Ubuntu necesitaras un USB vacío de al menos 4 GB.

1. Descárgate la aplicación Rufus, un sencillo programa gratuito, que se encarga de montar la imagen en el USB. En mi caso utilicé la versión portable, 925kb.
2. Descargate la última versión de Ubuntu u otra versión que desees. Es aconsejable usar las versiones LTS (Long Time Support) si estáis buscando algo más estable.
3. Éjecuta la aplicación Rufus

Simplemente abrir la aplicación

4. Selecciona el sistema de archivos FAT32 y seleciona "Crear un disco arrancable usando ..." y selecciona la imagen previamente descargada de Ubuntu o similares.

Haz click en el icono del disco para buscar la imagen deseada

Selecciona desde la carpeta de descargas

5. Selecciona crea una imagen ISO

Crear imagen ISO, recomendado

6. Saldrá un menú de advertencia. Clickamos que sí y el programa descarga de internet los archivos restantes.

Aceptamos descargar de internet el archivo

7. Espera a que finalice. En mi caso fueron unos 10 minutos.

8. presiona cerrar y reinicia el ordenador para arrancar desde el USB. Para arrancar desde el USB deberás apagar la computadora y al encenderla otra vez entrar en la BIOS. Para entrar en la configuración Bios depende de cada marca de ordenador, pero las más habituales son F2, F12, ESC, Supr., o DeleteEn mi caso tengo un ASUS y he entrado pulsando ESC.
9. Una vez en la Bios, este menú negro estilo MS-DOS, puedes instalar Ubuntu en una Partición previamente hecha o usar Ubuntu desde el USB.

Tutorial ZYBO Linux (I): cómo cargar linux-Debian en ZYBO (Zynq) con una tarjeta SD

2017-03-19T23:46:00.000+01:00

Esta es la primera parte del tutorial ZYBO-Linux donde crearemos una imagen de Linux-Debian en una tarjeta SD para poder arrancar Linux desde la placa de desarrollo ZYBO (Zynq) de Digilent y crear después pequeñas aplicaciones. Este tutorial consta de varias partes:

ZYBO-Linux(I): Escribir la imagen de Linux-Debian en una SD
ZYBO-Linux(II): Instalar o arrancar Linux-Ubuntu PC
ZYBO-Linux(III): Programar en Linux, usar los periféricos. Prender un led en dispositivos Zynq

1- Primero descárgate la imagen de Linux-Debian precompilada en el enlace. Imagen Debian-Linux y descomprímela (deberá ocupar 3,9GB). Esta imagen de Debian lleva precargada la configuración para conectar via Ethernet a través del terminal. La IP es 192.168.1.120.

2- Descárgate e instala el programa Win32 Disk Imager (Open Source) que sirve para grabar imágenes en memorias USB o SD.

3- Ejecuta Win32DiskImager. Selecciona la imagen descomprimida y la unidad de destino. Cuidado en seleccionar correctamente la unidad, ya que podrías sobre escribir tu disco duro si eliges la unidad de disco erróneamente.

Seleccionar la imagen de Debian y la unidad de disco de destino

4- Selecciona crear MD5 Hash para comprobar que la descarga no está corrupta, y el resultado debe ser

cbaeef7e7f551052f5451957a5dbef43

5- Pulsa el botón de Escribir para flashear.

6- Descarga el archivo Kernel-ZYBO.

Contenido del archivo Kernel-zybo

6- Abre la carpeta contenedora de la tarjeta SD recién creada. Deberás sobreescribir o reemplazar estos archivos de la SD por los recién descargados. Es posible que no se pueda sobreescribir por que no hay suficiente espacio. Basta con eliminar los archivos de la SD para copiar los nuevos archivos en la SD.

7- A continuación introducir la SD en la placa ZYBO, previamente cambiando el jumper JP5 para cambiar el modo de programación SD y que arranque desde la SD.

A continuación ya puedes alimentar la ZYBO, lo más fácil es con el cable USB, y conectarte a la placa. Los siguiente pasos están en el siguiente tutorial ZYBO-Linux (II)

Actualización: Robot velocista

2015-05-06T00:00:00.000+02:00

Robot velocista

Este robot fue diseñado en el año 2011 con ayuda del departamento de electrónica de la Universidad de Cartagena para participar junto con el robot de sumo en la Liga Nacional de Robótica de Competición. (http://lnrc.es )

D }

Esquemas de Eagle de la placa de control:(click para ampliar)

Placa de sensores:

Más información próximamente.

Compilación: Robot de SUMO

2015-05-05T23:46:00.000+02:00

Robot de SUMO

La construcción de este robot ha sido el principal

tatami de juego

Los artículos relacionados con la construcción de

ruedas:

introducción

prototipado

molde

fabricación de las gomas

Para la electrónica:

microcontroladora

placa base

Puente H

Para la mecánica:

chasis

¿por qué Python?

2015-02-10T23:05:00.000+01:00

Python: es un lenguaje de programación fácil de aprender, multiplaforma, libre y gratuito que está sustituyendo a software comercial (MATLAB, Mathematica, MAPLE…) en universidades norteamericanas tales como MIT, Stanford o Caltech, y que se utiliza ampliamente por empresas como Google, Dropbox o la NASA. Fue introducido en Febrero de 1991 por Van Rossum.

Es un buen lenguaje para iniciarse en la programación, sobre todo por su simplicidad. Además hace más sencillo aprender más tarde un leguaje más complejo. Una vez que domine Python, la transición al entorno C parecerá mucho más natural.

La sintaxis enfatiza la legibilidad del código, por lo que Python permite centrarse en otras habilidades sin tener que preocuparse demasiado acerca de la sintaxis.

Algunos expertos coinciden en que C es aproximadamente 10 veces más rápido durante el tiempo de ejecución, aunque la diferencia de velocidad es apenas perceptible para la mayoría de aplicaciones. Pero, debido a que Python permite escribir partes del código en c, se puede realizar un análisis "profiling" del código y saber dónde están los "cuellos de botella" para así poder depurar esas partes en C.

En general un programa en python suele ser bastante más corto que su equivalente en lenguajes como C y es considerado por muchos un lenguaje de programación de muy alto nivel. Lenguajes de alto nivel como Python o MATLAB están optimizados para humanos, mientras que lenguajes de de nivel inferior, como Fortran y C, están optimizados para ordenadores. Esto significa que con Python es más rápido y sencillo para el programador, mientras que para el sistema es más complejo y viceversa para C.

¿Ventajas?

Una ventaja fundamental de Python es la gratuidad de su intérprete, descargate el intérprete en www.python.org y por ello consta de mucha popularidad dentro del mundo del software libre y especialmente dentro de la comundad de GNU/Linux. Aunque también es importante que se obtienen buenos resultados con pocas líneas de código. Fácil aprendizaje, en comparación con otros lenguajes.

También puede ser, por qué no, una oportunidad más en el futuro profesional. Un exitoso programadore domina con fluidez varios idiomas.Y debido a que Python tiene una curva de aprendizaje mucho más corta que otros lenguajes y podrá crear programas significativos en un corto período de tiempo.

Para aprender hay algunos cursos online como este en edX

Yo empecé haciendo un par de cursos de coursera.org ("Programación para todos, introdución al Python"), además con la ayuda del libro del profesor: Python para informáticos para consultar dudas y tener toda la información a mano pude avanzar bastante.

IAR vs CCS

2015-02-03T19:55:00.000+01:00

La pregunta para compara ambos conocidos compiladores: ¿descargar IAR embedded workbench o Code Compose Studio CCS?

En general IAR produce un código más optimizado que CCS. (dicen que IAR es capaz de producir un código 30% o 40% más pequenio que el mismo producido por CCS)

Pero todo es cuestión de gusto y con que entorno se siente uno más cómodo.

Limitacion de la versión de prueba, IAR tiene un código máximo de 8Kb en cambio CCS tiene 16Kb.

Precio CCS es más económico que IAR.

Descargar aquí la versión de Prueba de IAR

A continuación se pueden ver dos capturas de pantalla:

IAR Workbench

Code Composer Studio

Energia: MSP430 + Energia = Arduino :)

2015-02-03T19:31:00.000+01:00

Energia es un plataforma de programación, iniciada en Enero de 2012 por Robert Wessels para poder programar LaunchPad de texas instruments con el mismo entorno de Arduino. Programar las LaunchPad de TI (Msp430, TM4C, C200 y CC32000) con el lenguaje de Aruino y Wiring. Este lenguaje es mucho más sencillo y fácil de aprender, sobre todo para gente no iniciada en programación. En definitiva: No hace falta estudiar ingeniería para empezar a realizar projectos de aficionado.

La ventaja es que hay millones de usuarios de Arduino, desde hace anios, compartiendo funciones,librerías y códigos que ahora pueden ser usados para texas instruments. Para todo aquel que haya programado Arduino, no notará la diferencia (el cambio de color IDE, del azul al rojo)

Izquierda Arduino. Derecha Energia

Energia sería la alternativa fácil a CCS o IAR Workbench. Sin embargo sólo lo recomendaría para aficionados, Hobyistas. Para estudiantes de Ingeniería/Ingenieroso o con conocimientos en programación que deseen aprender realmente cómo usar un microcontrolador, es mejor programar directamente en C. Ya que con Arduino/Energia sólo puedes acceder a funciones básicas y a un código ineficiente.

Ventajas/inconvenientes:

Energia usa librerías y funciones de otros procesadores, y estos son convertidos, Energia es mucho más lento e ineficiente que CCS o IAR. Las librerias de Arduino/Energia no son en general nada eficientes.
Arduino sirve como un buen medio educacional para colegios/institutos o incluso universidades o para electronica de aficionado a bajo nivel, pero no es capaz o no es recomendable usarlo en projectos serios o de manera profesional.

En definitiva Arduino/Energia es un "Playground" para experimentos con microcontroladores, pero no la base de un producto (serio) del "Real world".

Con Energia no podrás cambiar, por ejemplo las configuraciones del Clock o los timers por ejemplo.
En comparación del Hardware: LaunchPad usa 3.3V en lugar de los 5V de Arduino. LaunchPad usa un controlador de 16Bit y Arduino de 8Bit (aunque Arduino Due usa un núcleo 32Bit ARM-Cortex M3 hasta 72 MHz). Los kits de Texas Instruments son, en general, algo más económicos.

Cómo empezar a usar Energia?

Ir a la página de Energia, instalar la última versión del Software e iniciar los múltiples tutoriales de la misma página o de los que hay por la red, ver ejemplos y projectos similares a lo que estemos pensando hacer.

nueva LaunchPad Texas Instruments

2015-02-01T19:29:00.000+01:00

Texas instrument es una de las empresas lider en el sector de los semiconductores. La firma americana ofrece cuatro familias de microcontroladores en diferentes segmentos de mercado:

bajo consumo MSP430-16-Bit
los potentes C2000-32Bit con función en Realtime
Tiva C-Series con ARM®-MCU
Hercules con núcleo ARM-MCU para aplicaciones de alta seguridad

Desde 2010 Texas Instruments cambió ligeramente su política cuando un manager propuso desarrollar una placa de 10$. Desde 2009 TI tiene en el mercado productos de bajo coste, y en principio, bajas prestaciones. La llamada "value Line" 16 Bit-Controller cuenta únicamente con 512Byte de RAM. Dos años después se lanzó al mercado la C2000-LaunchPad por 15€ con un micro de 32Bit y 60MHz. Mas adelante salió la Hercules-LaunchPad con un doble núcleo, ideado para aplicaciones redundantes de alta seguridad.

La nueva LaunchPad Msp430f5529 con un coste de 12,99$ (Enero 2015), que aunque en comparación por el mismo precio puedas conseguir una LaunchPad Tiva C-Series 32Bit ARM con núcleo Cortex-M4. La nueva LaunchPad tiene un microcontrolador más potente con 40 pines disponibles para conectar los llamados Booster Pack. Los BoosterPacks se puede comprar, en la misma página oficial o en otros fabricantes, y permiten conectar fácilmente diferentes sensores o dispositivos.

Pin Out

Para inciarse en la nueva LaunchPad recomiendo la siguiente info:

Bit set, reset, toogle y masking en microcontroladores. Tutorial

2014-11-30T11:34:00.001+01:00

Hay diferentes conceptos que hay que tener claro antes de empezar a configurar los registros de un microcontrolador.

Bit set

Para escribir un 1en un determinado bit, usamos la puerta lógica OR. Si anteriormente en este bit del registro teníamos un 1 el 1 se queda y si teníamos un 0 el bit 1 es escrito encima.

En lenguaje C se usa el símbolo de la barra seguido de un igual: |=

ejemplo:

ADC12CTL0 |= ADC12ENC;

Bit reset

Queremos escribir un 0, y usamos la puerta lógica AND.

El símbolo en C utilizado es: &=

ejemplo:

ADC12CTL0 &= ~ADC12SC

Como se puede ver arriba se ha utilizado el símbolo ~, que es equivalente a una puerta not, (una negación) Y esto es porque queremos escribir un 0.

Bit Toggle

Toggle significa cambiar de un estado al otro. Es decir si un led está encendido apagarlo y si estuviese apagado encenderlo. Para esto se utiliza la puerta OR-exclusiv.

En lenguaje C el símbolo es: ^=

Bit masking

Usamos puerta AND para comprobar un determinado bit.

Multicópteros: Indice-resumen de post publicados!

2014-11-16T17:52:00.003+01:00

Actualización: Descarga ahora el PDF con toda la información del proyecto

Multicópteros

Aqui un resumen de todo lo que se ha ido publicando sobre el tema.

Introducción

Fotografía aérea comercial

Configuraciones Tri-, quad-, hexa- y octocóptero

Porqué y cómo vuela un cuadricóptero

Diseño: Los artículos relacionados con el diseño y dimensionamiento,

Presupuesto aproximado

Dimensionamiento de Hélices y motores

Funcionamiento:

Controlar un motor Brushless

Cableado para multicopteros

2012-11-18T11:52:00.001+01:00

El cable utilizado está recubierto de silicona pura, se pueden ver los diferentes grosores en la ilustración, y está muy extendido en el campo del aeromodelismo y sus principales características son:

· Para igual amperaje son mucho más flexibles que un cable tradicional.

Soportan 200 ^oC.
Baja resistencia y por tanto alta conductividad.
Están compuestos por cables de cobre muy finos, entre 0,06 y 0,08 mm, dependiendo del modelo.

En el prototipo se han utilizado dos grosores: 12AWG y 16AWG en colores negro y rojo.

Tabla de corrientes máximas admisibles dada por el fabricante:

AWG	Área	Diámetro	Corriente Máxima
20	0.518mm²	0.812mm	Hasta 12A
18	0.82mm²	1.02mm	Hasta 20A
16	1.31mm²	1.29mm	Hasta 30A
14	2.08mm²	1.63mm	Hasta 45A
12	3.31mm²	2.05mm	Hasta 70A
10	5.26mm²	2.59mm	Hasta 120A

En la ilustración se puede distinguir tres segmentos de cable, marcados con los números 1, 2 y 3. Para el segmento 1, que conecta las baterías con la placa de distribución, la máxima corriente es 60A. El tramo 2, que conecta la placa de distribución con los ESC, se utiliza el cable que llevan los variadores que es del grosor 16AWG. Para el último segmento, número 3, que conecta la salida de los variadores de velocidad con los motores, la máxima corriente es 11’5A y usaremos 16AWG.

Se han usado dos tipos de conectores:

Conectores “Bannana 3,5mm” que soportan alrededor de 80A.
Conectores “Bannana 4 mm” soportan hasta 93A aproximadamente y tienen protección contra inversión de la polaridad. Estos conectores son dobles, como se puede ver en la ilustración.

Ver más temas en Multicópteros.

Tiempo de vuelo

2012-11-18T11:43:00.001+01:00

Se han usado baterías de polímeros de Litio, conocidas como LiPo. Esta tecnología de baterías es la evolución de las baterías Li-ion y han remplazado a la antiguas NiMh o NiCd, ya que dobla la densidad de energía y aumenta la capacidad de descarga.

Se quiere que el tiempo de vuelo ronde los 10 minutos. Como su cálculo sólo lo podemos saber a partir de datos experimentales, para calcular una estimación a la baja, se procede de la siguiente manera:

La corriente máxima en continuo de cada motor, en nuestro caso, es 13.1A, (ver como cómo calcular los motores aquí) por lo que los 6 motores van a ser 78.6A.

Se suponen dos casos de baterías: 2 baterías de 4000mAh y 2 baterías de 5000 mAh.

En el primer caso tendremos un total de 8000mAh, eso significa que con la batería se pueden obtener 8000 mA durante una hora.

En el segundo caso de 10000 mAh:

Estos tiempos serían los obtenidos en el peor de los casos en los que cada motor trabajase al máximo. Si esto fuese así obtendríamos 896g de empuje en cada motor, un total 5376 gramos de empuje cuando el prototipo pesará menos de 3000 gramos.

Se puede calcular la aceleración máxima de subida:

Suponemos que cada motor da una media de 850 gramos de empuje, el total sería 5100 gramos. Cómo el peso del prototipo va a ser cómo máximo 3000g (sin carga), obtenemos un empuje neto ascendente de 2100gramos.

Según la segunda ley de newton: F= Mprototipo· a y sustituyendo la fuerza por se obtiene: F= Mempuje· g

Ver más temas en Multicópteros.

ESC: Electronic Speed Controler.

2012-11-18T11:23:00.003+01:00

Para controlar estos motores utilizamos los variadores ESC (Electronic Speed Controler), que están diseñados para dirigir a motores sin escobillas brushles. Estos pequeños controladores varían la corriente continua procedente de las baterías LiPo a corriente alterna de diferentes frecuencias, controlando así la velocidad de salida del motor. El principal parámetro para dimensionarlos es el amperaje máximo admisible, que debe ser superior a la máxima corriente que van a consumir los motores en continua.

Normalmente, poseen, internamente, un microcontrolador programable para configurar algunos parámetros. Esto depende de cada modelo. En este proyecto se han usado ESCs de la marca Turnigy, solamente programables con las tarjetas programadoras de la misma compañía.

Los parámetros variables son:

· Activar el freno (yes/no)

· Tipo de batería (LiPo/NiMh)

· Tipo de Corte ante batería baja (soft-cut/ off-cut)

· Corte por voltaje (Low/Middle/High)

· Mode de arranque (Normal/soft/very soft)

· Temporizador (Low/Middle/High)

· Música en function de las células de la batería (D/C/B/A)

· Modo Governor (on/off)

Realmente los parámetros que vienen por defecto son los mejores y no se necesita cambiar nada, excepto si deseas un arranque super suave, que pueden ser útiles si la batería o el propio ESC no están bien dimensionados para soportar el pico en el arranque.

El conexionado del ESC:

Para este proyecto se han usado unos variadores de corriente admisible de 40 A de la marca Turnigy, como los de la imagen, ya que los motores seleccionados pueden llegar a consumir 30 A en pico. Muchos de estos controladores reducen también el alto voltaje procedente de las baterías, 11,1 V a 5V para alimentar a la electrónica. Disponemos en este modelo una alimentación para la electrónica de 3A de máximo, más que suficiente para este proyecto.

Es importante alimentar la electrónica sólo desde una fuente de 5V, ya que al ser transformadores de tensión diferentes puede alimentar a la electrónica con una pequeña variación de voltaje, creando recirculaciones de corriente indeseadas.

La señal que hay que enviar al variador para controlar la velocidad es igual a la usada para controlar motores servo. Y su frecuencia de refresco es de 20 milisegundos.

Ver más temas en Multicópteros.

C Code- Draft!

2012-10-26T19:42:00.002+02:00

PARA UNA MEJOR LECTURA DEL CÓDIGO, COPIAR Y PEGAR EN LA VENTANA DE ARDUINO!

#include <APM_RC.h> // ArduPilot Mega RC Library
#include <FastSerial.h>
#include <SPI.h>
#include <Arduino_Mega_ISR_Registry.h>
#include <AP_PeriodicProcess.h>
#include <AP_InertialSensor.h>
#include <AP_IMU.h>
#include <AP_ADC.h>
#include <AP_Math.h>
#include <AP_Common.h>
#include <DataFlash.h>
#include <AP_Compass.h> // Compass Library
#include <I2C.h>
                          //para dataflash
#define HEAD_BYTE1 0xA3
#define HEAD_BYTE2 0x95
#define END_BYTE1 0xA2
#define END_BYTE2 0x4E
#define DF_SLAVESELECT 53 

#define ToRad(x) (x*0.01745329252)  // *pi/180
#define ToDeg(x) (x*57.2957795131)  // *180/pi


#define A_LED_PIN        35
#define C_LED_PIN        37
#define LED_ON           LOW
#define LED_OFF          HIGH

#define MIN 1235        //evitamos que los motores se paren
#define MAX 1500
#define CORTE 1200

Vector3f accel;   //viene de la libreria math.h y es un vector 3D
Vector3f gyro;
FastSerialPort(Serial, 0);

AP_Compass_HMC5843 compass;


Arduino_Mega_ISR_Registry isr_registry;
AP_TimerProcess  adc_scheduler;
APM_RC_APM1 APM_RC;
DataFlash_APM1 DataFlash;
///////////////////////////////////////////////////////////////////////////////////////////////////////////
                //processing
//int velocidadX=0,velocidadY=0;
//int anguloX=0,anguloY=0;
//int T,W,X,Y;
              //variables MOTORES
              int valor1=0;
float throttle=MIN;
float valor[7],valorF[7];
float pitch,roll;
//Serial
int aux=0,aux2=0;
byte recived;
boolean estado=false,datos=true;
int8_t m_opp[7]={0,2,1,4,3,6,5};
//////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////
       //CONTROLADO1
                                                                                                      float KpP=50,KdP=400,KiP=0.1;    //PITCH    //50  400 0.1
                                                                                                      float KpR=50,KdR=300,KiR=0.1;     //Roll    //60 300 0.1
                                                                                                
                             //PITCH             
float pitchSum=0,lastPitch=0,lastPitchFilter=0,pitchFilter=0;
float giroPitch=0,lastGiroPitch =0,giroPitchFilter=0,lastGiroPitchFilter=0;
                            //Roll
float rollSum=0,lastRoll=0,lastRollFilter=0,rollFilter=0;
float giroRoll=0,lastGiroRoll=0,giroRollFilter=0,lastGiroRollFilter=0,giroRoll2=0;    //giroRoll lo usamos para hacer la derivación numérica
float errorPitch=0,errorRoll=0;
                  //YAW
                  float compas=0;  int kyaw=5; int yawi=0;    
int counter=0;
               //DATALOG
long timer=0,timer1=0;
                //INPUTs
float xref=0,yref=0,yaw=0,yawref=0;
/////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
AP_ADC_ADS7844 adc;
AP_InertialSensor_Oilpan oilpan_ins(&adc);
AP_IMU_INS imu(&oilpan_ins,0);

static void flash_leds(bool on)
{
    digitalWrite(A_LED_PIN, on?LED_OFF:LED_ON);
    digitalWrite(C_LED_PIN, on?LED_ON:LED_OFF);
}

///////////////////// T I M E R S
static uint32_t      fastTimer; 
static uint32_t      fast_loopTimer;    
static byte    medium_loopCounter;  
static uint32_t         fiftyhz_loopTimer;

static byte    slow_loopCounter;
static int16_t   superslow_loopCounter;
static byte    counter_one_herz;
////////////////////

void setup(void)
{
 Serial.begin(115200);
        menu();                  //imprime por menu las opciones para leer o borrar la memoria del log
    I2c.begin();
  I2c.timeOut(20);
  
   if (!compass.init()) {
   Serial.println("compass initialisation failed!");
   while (1) ;
  }
  
    isr_registry.init();
    adc_scheduler.init(&isr_registry);
    APM_RC.Init(&isr_registry);  // APM Radio initialization
  APM_RC.enable_out(CH_1);
  APM_RC.enable_out(CH_2);
  APM_RC.enable_out(CH_3);
  APM_RC.enable_out(CH_4);
  APM_RC.enable_out(CH_5);
  APM_RC.enable_out(CH_6);
  APM_RC.enable_out(CH_7);
  APM_RC.enable_out(CH_8);
  
  APM_RC.OutputCh(1, valor1);
  APM_RC.OutputCh(2, valor1);
  APM_RC.OutputCh(3, valor1);
  APM_RC.OutputCh(4, valor1);
  APM_RC.OutputCh(5, valor1);
  APM_RC.OutputCh(6, valor1);

DataFlash.Init();
 DataFlash.StartWrite(1); //empezamos a escribir en la página nº1



 
    /* Should also call ins.init and adc.init */
 imu.init(IMU::COLD_START, delay, flash_leds, &adc_scheduler);
 imu.init_accel(delay, flash_leds);Serial.print("\n");
        funcion_serial();
fast_loopTimer=micros();timer1=micros();
 compass.set_orientation(AP_COMPASS_COMPONENTS_DOWN_PINS_FORWARD);  // set compass's orientation on aircraft.
  compass.set_offsets(0,0,0);  // set offsets to account for surrounding interference
  compass.set_declination(ToRad(0.23));  // set local difference between magnetic north and true north para cartagena/murcia la declinación es 0.28
}

void loop(void)
{
int32_t timer    = micros();

if ((timer - fast_loopTimer) >= 10000) {    //400 Hz
  
                 fast_loop();
                 fast_loopTimer=micros();
  }
if ((timer - fiftyhz_loopTimer) >= 20000) { // reads all of the necessary trig functions for cameras, throttle, etc.
  fiftyhz_loopTimer = timer;
  
         medium_loop();    //10 Hz

  fiftyhz_loop();    //50 Hz

  counter_one_herz++;

  if(counter_one_herz == 50){
       super_slow_loop();    //1 Hz
   counter_one_herz = 0;
  }

                }
}//cierra el void loop


            // F U N C I O N E S
            
            static void fast_loop()
{
 if(estado){
                imu.update();
                accel = imu.get_accel();
                gyro =  imu.get_gyro();
         pitch    =  accel.y; 
         roll     =  accel.x; 
         giroPitch=  gyro.x;
         giroRoll = gyro.y; 
        
         
                                //FILTER pitch
          pitchFilter=lastPitchFilter*0.9048 + 0.09516*lastPitch; //giroRoll2 = ((pitchFilter-lastPitchFilter)*100000)/(micros()-timer1); timer1=micros(); derivacion numérica
         // giroPitchFilter=lastGiroPitchFilter*0.6703   + 0.3297  *lastGiroPitch;
                               //filter Roll
         rollFilter=lastRollFilter*0.9048 + 0.09516*lastRoll;
        // giroRollFilter=lastGiroRollFilter*0.07318 + 0.9268  *lastGiroRoll;    //filtro t=0.0038,  G=tf([1],[0.05 1]);c2d(G,0.0038) ensayo d9_10 demasiado suave
        //  giroRollFilter=lastGiroRollFilter*0.141 + 0.859  *lastGiroRoll;   // G=tf([1],[0.025 1]);c2d(G,0.0038
            giroRollFilter=lastGiroRollFilter*0.00253 + 0.9975  *lastGiroRoll;    //G=tf([1],[1.5 1]);c2d(G,0.0038)     parece que funciona
        //CUando no tenemos filtro
          // rollFilter = roll;        //si activamos o desactivamos los filtros, hay que activar el actualizar los valores abajo de la funcion
         //  pitchFilter = pitch;   
         
          giroPitchFilter=giroPitch;
          pitchSum +=errorPitch;             //integral
           
          //giroRollFilter=giroRoll;
          rollSum += errorRoll;             //integral
                errorPitch=yref-pitchFilter;
                errorRoll=xref-rollFilter;                                                                                                   
                                         //FRONT      RED           
                                          valor[1] = throttle + 1.0* (KpR*errorRoll   - KdR*giroRollFilter   + KiR*rollSum);
                                          valor[5] = throttle + 0.5* (KpR*errorRoll   - KdR*giroRollFilter   + KiR*rollSum) -0.866* (KpP*errorPitch +KdP*giroPitchFilter + KiP*pitchSum);
                                          valor[4] = throttle + 0.5* (KpR*errorRoll   - KdR*giroRollFilter   + KiR*rollSum) +0.866* (KpP*errorPitch +KdP*giroPitchFilter + KiP*pitchSum);
                                            //BACK  BLACK 
                                          valor[2] = throttle - 1.0* (KpR*errorRoll   - KdR*giroRollFilter   + KiR*rollSum);
                                          valor[3] = throttle - 0.5* (KpR*errorRoll   - KdR*giroRollFilter   + KiR*rollSum)  -0.866* (KpP*errorPitch +KdP*giroPitchFilter + KiP*pitchSum);
                                          valor[6] = throttle - 0.5* (KpR*errorRoll   - KdR*giroRollFilter   + KiR*rollSum)  +0.866* (KpP*errorPitch +KdP*giroPitchFilter + KiP*pitchSum);
                                          
                                          //     CONTROL DEL YAW
                                         /* yaw=compas-yawref; yawi=+yaw;
                                           valor[1] +=kyaw*yaw +yawi;
                                           valor[3] +=kyaw*yaw +yawi;
                                           valor[6] +=kyaw*yaw +yawi;
                                           
                                           valor[2] -=kyaw*yaw -yawi;
                                           valor[4] -=kyaw*yaw -yawi;
                                           valor[5] -=kyaw*yaw -yawi;*/
     //////////////////////////////////////////////////////                                 
                            escribe_data();         //////              
                                           for(int8_t m=1;m<=6;m++){    //TRIDGE STABILITY PATCH pag 49 hexamotors. Recalcula las velocidades si alguna de ellas satura.
                                             if(valor[m]>MAX){
                                               valor[m_opp[m]]-=valor[m]-MAX;
                                               valor[m]=MAX;
                                             }}
                                                                                                
                                          for(int8_t i=1;i<=6;i++){                 //CONSTRAIN --> limites superior e inferior
                                            valor[i] = constrain(valor[i],MIN,MAX);
                                          }
                                      
                                      /*
                                                                  //FILTRO que frena la acelearcion contra la deceleracion
                                            for(int8_t m=1;m<=6;m++){
                                              if(valorF[m]<valorF[m]){   //es porq estamos acelerando
                                                      valorF[m]=(valor[m]+valorF[m])/2;
                                              } else{                     //no filtramos     
                                                       valorF[m]=valor[m];                                
                                              }}
                                      */
                                      /*
                                      if(counter=100){
                                       pitchSum=0;          //reseteamos integral en un determinado tiempo
                                     // rollSum=0;
                                     counter=0;
                                     
                                      }
                                      counter++;
                                      */
                                          actualiza_motores();

                           //actualizamos los valores pitch para el filtro
                                                                    lastPitch=pitch;
                                                                   // lastGiroPitch=giroPitch;
                                                                   lastPitchFilter=pitchFilter;      
                                                                   //lastGiroPitchFilter=giroPitchFilter;
                                                                   
                                                                  lastRoll=roll;
                                                                  lastGiroRoll=giroRoll;
                                                                  lastRollFilter=rollFilter;
                                                                  lastGiroRollFilter=giroRollFilter;
                                                                                                     
                                                        
                 }//cerramos if(estado) 
             else{   funcion_serial();                            //Si el throttle está a cero --> imprimimos VELOCIDAD CERO a los motores! y calibramos el PID
                     for(int8_t i=1;i<=6;i++){   
                             APM_RC.OutputCh(i, 0);
                                          }
                 }
      
      
      /*
      if(estado){   //imprime datos por Serial.Monitor
Serial.printf(" %4.4f , %4.4f , %4.4f , %4.4f , %4.4f , %4.4f ,",
       accel.x, accel.y, rollFilter, gyro.x, gyro.y, pitchFilter);Serial.print(millis());
          Serial.print(",");Serial.print(valor[1]);
          Serial.print(",");Serial.print(valor[2]);
          Serial.print(",");Serial.print(valor[3]);
          Serial.print(",");Serial.print(valor[4]);
          Serial.print(",");Serial.print(valor[5]);
          Serial.print(",");Serial.print(valor[6]);
          Serial.print(",");Serial.print(xref);
          Serial.print(",");Serial.print(yref);           
                    Serial.print(",");Serial.print(throttle); 
                              Serial.print(",");Serial.println(yaw);                     
          }*/

} //cierra fast_loop

static void medium_loop()
{
  switch(medium_loopCounter) {

  // Tenemos en cuenta el Compass
  //-----------------------------------------
  case 0:
   medium_loopCounter++;
                         compass.read();
                         compass.calculate(0,0);
                         compas=ToDeg(compass.heading);
                         Serial.print(compas);Serial.print(",   ");Serial.print(yawref);Serial.print(",   ");Serial.println(yaw);
                        
                      

                         break;

  // Leemos valores de las referencias
  //------------------------------------------------
  case 1:
   medium_loopCounter++;
                           yref=(APM_RC.InputCh(CH_2)-1050);yref/=210;yref-=2;yref=constrain(yref,-1,1);    //pitch
                           //xref=(APM_RC.InputCh(CH_2)-1050);xref/=210;xref-=2;constrain(xref,-0.5,0.5);    //roll
                             //yaw=APM_RC.InputCh(CH_4)-1050;yaw/=100;yaw-=4;
                     
   break;

  // command processing
  //-------------------
  case 2:
   medium_loopCounter++;

   
   break;

  // This case deals with sending high rate telemetry
  //-------------------------------------------------
  case 3:
   medium_loopCounter++;
                     
          


   break;

  // This case controls the slow loop
  //---------------------------------
  case 4:
   medium_loopCounter = 0;

   break;

  default:
   // this is just a catch all
   // ------------------------

   medium_loopCounter = 0;



   break;
 }
  
  
  
}//fin medium_loop


static void fiftyhz_loop(){   //leer datos del acelerador

           if(APM_RC.InputCh(CH_3)>CORTE){  
         // throttle = APM_RC.InputCh(CH_3);       //acelerador variable
          throttle=1280;                                //acelerador constante
         estado=true;
      // escribe_data();                                 //RECIBIMOS DATOS CADA 50HZ (20ms()
     }else{estado=false;timer=millis();}
      
      }


static void super_slow_loop()           //loop de un Herz
{
  
  
  
}
void actualiza_motores()
{
   for(int8_t i=1;i<=6;i++){    //el throttle está funcionando --> IMPRIMIR las VELOCIDADES a los motores
                                                  APM_RC.OutputCh(i,valor[i]);
                                                  
                                          }
}
static void escribe_data()
{
                DataFlash.WriteByte(HEAD_BYTE1);
  DataFlash.WriteByte(HEAD_BYTE2);
  DataFlash.WriteInt(rollFilter*10000);            //rollFIlter
  DataFlash.WriteInt(pitchFilter*10000);            //pitch filter
  DataFlash.WriteInt(giroRollFilter*10000);            //gyroRoll
  DataFlash.WriteInt(gyro.y*10000);            //gyroPitch
  DataFlash.WriteLong((long)(millis()-timer));                    //time
  DataFlash.WriteInt(valor[1]);         //velocidades motores
  DataFlash.WriteInt(valor[2]);    //motor 1 y 2 para el roll
  DataFlash.WriteInt(valor[4]);    //motor 4 y 5 para el pitch
  DataFlash.WriteInt(valor[5]);    
  DataFlash.WriteInt(xref*100);              //x ref
  DataFlash.WriteInt(yref*100);              //yref
  DataFlash.WriteInt(compas*100);
  DataFlash.WriteInt(throttle);          //throttle
  DataFlash.WriteByte(END_BYTE1);  // 2 bytes of checksum (example)
  DataFlash.WriteByte(END_BYTE2); 

  
  
}
/*static void escribe_espacio()
{
                DataFlash.WriteByte(HEAD_BYTE1);
  DataFlash.WriteByte(HEAD_BYTE2);
  DataFlash.WriteInt();            //rollFIlter
  DataFlash.WriteInt(pitchFilter*10000);            //pitch filter
  DataFlash.WriteInt(gyro.y*10000);            //gyroRoll
  DataFlash.WriteInt(giroRollFilter*10000);            //gyroPitch
  DataFlash.WriteLong((long)(millis()-timer));                    //time
  DataFlash.WriteInt(valor[1]);         //velocidades motores
  DataFlash.WriteInt(valor[2]);    //motor 1 y 2 para el roll
  DataFlash.WriteInt(valor[4]);    //motor 4 y 5 para el pitch
  DataFlash.WriteInt(valor[5]);    
  DataFlash.WriteInt(counter);          //y ref
  DataFlash.WriteInt(throttle);          //throttle
  DataFlash.WriteByte(END_BYTE1);  // 2 bytes of checksum (example)
  DataFlash.WriteByte(END_BYTE2); 
  counter=0;
  
  
}*/
static void funcion_serial()
{
  if(Serial.available()>0){
    byte recived=Serial.read();
    if(recived==76||recived==108){ // L OR l
      
      //LEER
      int  i, tmp_int;
 byte  tmp_byte1, tmp_byte2;
 long  tmp_long;
 Serial.println("empezando a leer...");

 DataFlash.StartRead(1);  // We start reading from page 1

 for(int i;i<10000;i++){  // Read 1000 packets...
  
  tmp_byte1 = DataFlash.ReadByte();
  tmp_byte2 = DataFlash.ReadByte();
  
  if ((tmp_byte1 == HEAD_BYTE1) && (tmp_byte1 == HEAD_BYTE1)){
   // Read 4 ints...
   tmp_int = DataFlash.ReadInt();      //*10 000
if(isSpace(tmp_int)) {
  tmp_int = DataFlash.ReadInt(); if(isSpace(tmp_int)) {
      Serial.println("espacio encontrado");
                break;
    }}
   Serial.print(tmp_int);
   Serial.print(",");
   tmp_int = DataFlash.ReadInt();
   Serial.print(tmp_int);
   Serial.print(",");
   tmp_int = DataFlash.ReadInt();
   Serial.print(tmp_int);
   Serial.print(",");
   tmp_int = DataFlash.ReadInt();
   Serial.print(tmp_int);
   Serial.print(",");
   
   // Read 2 longs...
   tmp_long = DataFlash.ReadLong();
   Serial.print(tmp_long);
   Serial.print(",");

   // Read 6 ints...
   tmp_int = DataFlash.ReadInt();  //motores  
   Serial.print(tmp_int);
   Serial.print(",");
   tmp_int = DataFlash.ReadInt();
   Serial.print(tmp_int);
   Serial.print(",");
   tmp_int = DataFlash.ReadInt();
   Serial.print(tmp_int);
   Serial.print(",");
   tmp_int = DataFlash.ReadInt();
   Serial.print(tmp_int);
   Serial.print(",");
                        tmp_int = DataFlash.ReadInt();   //xref *100
   Serial.print(tmp_int);
   Serial.print(",");
                        tmp_int = DataFlash.ReadInt();   //yref *100
   Serial.print(tmp_int);
   Serial.print(",");
                        tmp_int = DataFlash.ReadInt();   //COMPAS *100
   Serial.print(tmp_int);
   Serial.print(",");
   tmp_int = DataFlash.ReadInt();  //throttle
   Serial.print(tmp_int);

      
   // Read the checksum... 
   tmp_byte1 = DataFlash.ReadByte();
   tmp_byte2 = DataFlash.ReadByte();
  }  
  Serial.println();
 }
 Serial.println("");
 Serial.println("lectura completada ");
 Serial.println("");
 
      while(1);
    }
    else if(recived==98||recived==66){ //B OR b
    
    //DELETE
    borrar();
    while(1);
    } 
  }
  
}
void dataflash_CS_inactivee()
{
  digitalWrite(DF_SLAVESELECT,HIGH); //disable device
}

void dataflash_CS_activee()
{
  digitalWrite(DF_SLAVESELECT,LOW); //enable device
}
 
static void borrar()
{
  dataflash_CS_activee();   
 SPI.transfer(0xC7);
 SPI.transfer(0x94);
 SPI.transfer(0x80);
 SPI.transfer(0x9A);
   dataflash_CS_inactivee();   
   Serial.println("Borrado de memoria Flash completado");
}
  static void menu()
  {
    Serial.println("Bienvenido;\n \t\t\t pulse.... \n 'L' para Leer datos \n 'B' para Borrar datos\n \t\t\t\t\t y despues INTRO");
  }

Banco de pruebas para multicópteros

2012-08-20T20:53:00.000+02:00

Con motivo de poder hacer pruebas e ir depurando código he estoy usando este soporte que utilizo como simulador.

Permite al hexacóptero moverse en los 3 ejes, Pitch, Roll y Yaw evitando posibles acidentes y daños materiales.

Rodamientos y potenciómetros que permiten conocer la posición exacta en cada momento

Plataforma para mi hexacopter:

Video en funcionamiento durante los ensayos:

El código en desarollo utiliza las librerías de ArduCopter, y tiene el siguiente esquema:

Aquí se puede ver una versión de prueba del código en C para el hexacóptero.

Dimensionar.Cómo elegir los motores y Hélices para cuadricópter o multicóptero. Tutorial

2012-07-05T13:50:00.000+02:00

Hay que tener en cuenta que hay tomar como un conjunto Motor + Hélice, ya que cada motor se comporta de manera diferente con diferentes tipos de hélices.

Para el dimensionamiento del conjunto se ha usado el programa “Drivecalculator 3.4” que es una herramienta para el análisis de motores Brushless para vehículos aéreos radiocontrol. Este programa contiene una base de datos actualizada con los motores, hélices, ESCs, baterías, estatores y engranajes de transmisión. Así podemos simular el comportamiento de los diferentes elementos.

Para el proceso de elección primero se ha elegido un catálogo de un distribuidor, en este caso Hobbyking un distribuidor de artículos de aeromodelismo y radio control bastante importante y conocido a nivel mundial con almacenes en Hong-Kong, China, Australia, Alemania y Estados Unidos.

De entre los motores disponibles por el distribuidor hemos comparado siete motores brushless de la marca Turnigy, entre un rango de precio alrededor de 20$ la unidad. Turnigy es una marca asociada a hobbyking, así conseguimos una alta relación calidad/precio. Estos motores son:

Modelo	Kv (rpm/V)	peso (g)	precio
Tower Pro 3015	1000	133	$ 17.04
Turnigy 2217 16turn	1105	71	$ 15.38
Turnigy 2217 20turn	860	71	$ 14.04
Turnigy AerodriveXP SK 3548	900	171	$ 24.85
Turnigy AerodriveXP SK 3530	1074	79	$ 17.86
Turnigy 3632	1134	99	$ 19.71
NTM prop drive Series 35-36A	851	112	$ 18.83

Los modelos de hélices utilizadas, son quizá las más económicas del mercado actual. Todas las hélices de bajo coste necesitan ser balanceadas, es decir, no son exactamente simétricas en masa y forma. Por lo que precisan de un proceso de calibración previo. Este proceso consiste en colocar la hélice en un eje e ir limando hasta que se quede en equilibrio.
Cómo utilizar el Programa DRIVE CALCULATOR
Con la ayuda de este programa podemos conocer como se comportaría el conjunto de elementos batería + ESC + motor + caja de cambios + hélice. El proceso de diseño consiste en fijar todos los elementos menos los motores. Acto seguido pulsar en (buscar motores) y saldrá una lista de los motores adecuados a esa configuración y de entre esta lista seleccionaremos los que aparecen en el catálogo del distribuidor.

De esta primera gráfica se obtiene numerosa información:
Criterios de selección:

Modelo	Kv (rpm/V)	peso (g)	empuje (g)	corriente (A)	eficiencia (%)
Tower Pro 3015	1000	133	1324	23.6	70
Turnigy 2217 16turn	1105	71
Turnigy 2217 20turn	860	71	851	12.8	76.7
Turnigy AerodriveXP SK 3548	900	171	997	22.3	71.5
Turnigy AerodriveXP SK 3530	1074	79	1064	18.4	69.7
Turnigy 3632	1134	99	1385	26.1	74.3
NTM prop drive Series 35-36A	851	112	921	13.4	76.5

Modelo	Kv (rpm/V)	peso (g)	empuje (g)	corriente (A)	eficiencia (%)
Tower Pro 3015	1000	133	1324	23.6	70
Turnigy 2217 16turn	1105	71	1148	20.5	77.2
Turnigy 2217 20turn	860	71	851	12.8	76.7
Turnigy AerodriveXP SK 3548	900	171
Turnigy AerodriveXP SK 3530	1074	79
Turnigy 3632	1134	99
NTM prop drive Series 35-36A	851	112

· Peso: 112 gramos.
· Velocidad de giro: 8015 rpm.

Nota: “NTM prop drive Series 35-36A” es la nueva versión de “Turnigy SK 35-36A 910Kv”

De entre las hélices se han comparado sólo dos: APC 10x5 y APC 10x6. Nuestra estructura soporta un tamaño de hélice máximo de 12'', se ha elegido 10 por que se quiere un vuelo más estable (cuanto más grandes sean las hélices más tarda el helicóptero en reaccionar) y no se han elegido hélices más pequeñas para obtener más capacidad de carga.

En la nomenclatura de las hélices (“X”x”Y”), como se puede observar en la imagen, X corresponde a la longitud en pulgadas, y Y corresponde al paso, también medidos en pulgadas. El paso es la distancia que recorrería la hélice al girar una vuelta completa.

· Baterías: los parámetros a definir es el número de celdas de la batería que se ha fijado a 3 celdas, es decir 3x3.7 = 11.1Voltios. Al elegir una determinada batería indica el peso correspondiente.

· ESC: Para el variador de velocidad de motores brushless, el único parámetro que nos interesa es la máxima corriente que permite manejar. Para determinar qué ESC necesitamos basta con elegir el inmediatamente superior a la máxima corriente de consumo de los motores. Al elegir un determinado variador indica el peso correspondiente.

· Motores: Los motores van a ser el parámetro a variar, para así obtener el empuje y rendimiento deseado.

· Caja de cambios: Para este caso no usaremos reductora, ya que no es necesario.

· Hélices: Elegiremos dos hélices diferentes para comparar.

Realizando una búsqueda con los siguientes parámetros se obtienen 215 motores:

Parámetros:

· Batería: voltaje constante 10.8 Voltios.

· ESC: no registrado.

· Hélice: 10x6 GWS HD.

La gráfica muestra en puntos grises los motores que se adaptan a nuestros parámetros iniciales, marcando con un punto verde el motor seleccionado en ese momento. Los datos que se obtienen son el empuje (Schub) medido en gramos, Potencia (P) medida en Watios, rendimiento (Eta %) y velocidad (n) en revoluciones por minuto.

· Elegir sólo modelos del catálogo de nuestro distribuidor.

· El empuje de cada motor debe ser alrededor de 1000 gramos, pero no mucho más, ya que la estructura sólo soporta alrededor de 1kg por brazo.

· Limitamos las revoluciones de trabajo a 1000Kv (rpm/V) para evitar vibraciones excesivas.

Eligiendo los motores se elabora una tabla comparativa con cada hélice a testear:

Hélice APC 10x6:

Hélice APC 10x5:

Conclusiones: Los tres motores tienen similar curva de potencia a baja potencia hasta 20A. La velocidad del eje sí varía considerablemente entre los tres motores. Para evitar vibraciones se selecciona un motor que trabaje a bajas revoluciones.

Descartamos el modelo 3632, debido a las críticas de los consumidores que apuntan a una mala alineación de los polos magnéticos.

Elegimos el modelo 35-36A por trabajar a menos revoluciones y porque la curva de eficiencia no cae tanto como la otra, por lo que se reduce el calentamiento en el motor.

Una vez elegido el motor y hélice analizamos la información:

En la ilustración tenemos los parámetros del motor:

·         Torque: 0.914 Ncm/A.
·         Resistencia interna: 99.8 mOhm.
·         Velocidad de giro: 851 rpm/V.
·         Corriente de pico: 30A.
·         Rendimiento máximo 76.8%.

En la segunda imagen obtenemos los resultados de simular la combinación del motor con la hélice 10x6 :

·         Empuje estático: 896 gramos.
·         Velocidad pitch:73 km/h.
·         Eficiencia del empuje: 6.4 gramos/W.
·         Corriente: 13.1A.
·         Potencia de entrada: 141.0W.
·         Potencia de salida: 108.1W.
·         Eficiencia: 76.7%.

Porqué y como vuela un Cuadricoptero y Héxacoptero. Teoría.

2012-03-03T17:26:00.000+01:00

Existen 4 parámetros para describir los movimientos de este tipo de vehículo, la altitud, los ángulos Roll y Pitch y el ángulo Yaw. En las gráficas siguientes las flechas rojas indican la potencia del empuje de cada motor.

El control de la altura es relativamente sencillo, basta con variar la potencia de los motores. Como se puede ver en el gráfico XX igualando las velocidades de los cuatro motores y variando su valor se conseguirá más o menos altura.

Para el control de los ángulos Roll y Pitch se fijan iguales las velocidades de los motores situados sobre el eje que se quiere cambiar y variando las velocidades de los motores perpendiculares de manera desigual, el cuadricóptero se girará en uno y otro sentido como podemos ver en el gráfico XX.

Para regular el ángulo Yaw, se fijarán los motores que giren en el mismo sentido, y variando los motores que giran en sentido contraopuesto se girará hacia un lado u a otro.

Concluimos que tenemos que tener en cuenta 4 parámetros fundamentales para controlar el aparato:

Altitud --> barómetro [throttle]
Pitch --> acelerómetro/giróscopo [Pitch]
Roll --> acelerómetro/giróscopo [Roll]
Yaw --> acelerómetro/giróscopo/magnetómetro [Yaw]

Si se tiene en cuenta un sistema coordenado como el de la figura superior,en el caso del cuadricóptero, los parámetros Pitch y Roll coinciden con el giro de los ejes principales, X e Y.

No es así en el caso del hexacóptero que sólo coincide el eje Pitch:

Usando la trigonometría se calculan la equivalencia de los motores 3, 4, 5 y 6 con los ejes Roll y Pitch. En la figura inferior podemos ver, en este caso el motor nº5, es proporcional al sin(30) para Pitch y cos(30) para Roll.

Los sentidos de los ejes serían:

Se precisan unas ecuaciones que relacionen [throttle][Pitch][Roll][Yaw] con las velocidad de cada motor:

Para simplificar podemos despreciar, por el momento el factor YAW, que tiene que ver con la orientación.

          //FRONT                 
 valor1 = throttle               + 1.0* pitch;
 valor5 = throttle + 0.866* roll + 0.5* pitch;
 valor4 = throttle - 0.866* roll + 0.5* pitch
          //BACK
 valor2 = throttle               - 1.0* pitch;
 valor3 = throttle + 0.866* roll - 0.5* pitch;
 valor6 = throttle - 0.866* roll - 0.5* pitch;

Para tener en cuenta el ángulo YAW se varía la velocidad de los motores que giran hacia el mismo sentido.

//YAW
    //CW
   valor1 += yaw;
   valor3 += yaw;
   valor6 += yaw;
    //CCW
   valor2 -= yaw;
   valor4 -= yaw;
   valor5 -= yaw;

          


La numeración de los motores ha sido arbitraria, se puede ver en la figura XXX, donde los motores 1, 3 y 6  giran en sentido horario (Clockwise), y los 2, 4 y 5 giran en sentido antihorario (Counterclockwise).

Leer radio PPM desde un emisor RC y Arduino. Tutorial

2011-12-29T18:21:00.001+01:00

¿Qué diferencias hay entre leer la radio mediante PPM o mediante las señales de los servos?

Según Jordi Muñoz, Rendimiento y simplicidad en el código son los motivos para leer en PPM y no en PWM.

Una señal PPM (Pulse Position Modulation) integra todos los canales del receptor/emisor en una sola línea. Así usando sólamente un pin podemos leer los 8 canales de la radio. (Menos cables=menos problemas.)

La idea es leer las señales de radio con un Arduino auxiliar y mandar los datos de radio ya leídos e interpretados por SPI o i2C al Arduino principal.

Si desmontamos el receptor, desechando la carcasa y los pines (10x3= 30 pines) ahorramos alrededor del 70 % del peso. Que no es mucho en este caso,además también ahorra espacio.

click en la imagen para agrandar.

Los transmisores de radio suelen tener dos modos: PPM (Pulse Position Modulation) y PCM (Pulse Code Modulation). Ponerla en modo ACRO (sin mezclas), sin TRIM, no DUAL-RATE y tampoco EXPONENCIAL. Esto es para que las lecturas del equipo no se vean distorsionadas por el software de la emisora.

En el receptor Turnigy 9X 8CH V2 no se puede obtener en ningun sitio de su placa la señal PPM. Ya que este cuenta con dos micros, uno receptor y el otro decodificador, los cuales se comunican por SPI. Aquí una lista de como hackear receptores para sacar la señal PPM enlace.

Aquí otra solución alternativa para obtener la salida PPM mediante un Chip extra, pero si puedes acceder a esta señal mucho más fácil, ¿no?
Si no sabemos donde está nuestra señal PPM podemos cargar este programa (de Jordi) e ir comprobando todos los pines con el Serial Monitor hasta ver valores aleatorios de entre 300 y 9000, lo que significará que ya hemos encontrado el pin PPM. No olvidar interconectar las tierras del receptor y arduino!!

void setup()
{
Serial.begin(57600);
pinMode(3, INPUT);
}
void loop()
{
Serial.println(pulseIn(3, LOW));
}

Los programas usados fueron creados por Jordi Muñoz y subidos al blog de Arduino el 1 de Enero de 2008.

Lector PPM básico Arduino

#define channumber 6 //Cuantos canales tiene tu radio?/How many channels have your radio?
int channel[channumber]; //Valores de canales leidos/ readed Channel values
int PPMin = 4;

void setup()
{
  Serial.begin(9600); //Iniciamos com serial/
  pinMode(PPMin, INPUT); //Patita 4 como entrada / Pin 4 as input
}

void loop()
{
  //Espera hasta que la senal de sincronizacion llegue, debe ser > 4 milisegundos
  //waits ultil synchronize arrives > 4 miliseconds
  if(pulseIn(PPMin , HIGH) > 4000); //Si el pulso del pin 4 es > que 4 msegundos continua /If pulse > 4 miliseconds, continues
  {
    for(int i = 1; i <= channumber; i++) //lee los pulsos de los demas canales / Read the pulses of the remainig channels
    {
 channel[i-1]=pulseIn(PPMin, HIGH);
    }
    for(int i = 1; i <= channumber; i++) //Imprime los valores de todos los canales / Prints all the values readed
    {
 Serial.print("CH"); //Canal/Channel
 Serial.print(i); // Numero del canal / Channel number
 Serial.print(": "); // que te importa
 Serial.println(channel[i-1]); // Imprime el valor/ Print the value
    }
    delay(200);//Le da tiempo para imprimir los valores en el puerto/ Give time to print values.
  }
}


Lector PPM básico con filtro Antisalto:


#define channumber 6 //Cuantos canales tiene tu radio???????/How many channels have your radio???
#define filter 10 // Filtro anti salto/ Glitch Filter
int channel[channumber]; //Valores de canales leidos/ readed Channel values
int lastReadChannel[channumber]; //Ultima lectura obtenida/ Last  values readed
int conta=0; //Contador/couter


void setup()
{
  Serial.begin(9600); //Iniciamos com serial/ Serial Begin
  pinMode(4, INPUT); //Patita 4 como entrada / Pin 4 as input
  pinMode(13, OUTPUT); // Led pin 13
}

void loop()
{

  if(pulseIn(4, HIGH) > 3000) //Si el pulso del pin 4 es > 3000 usegundos continua /If pulse > 3000 useconds, continues
  {
    for(int i = 0; i <= channumber-1; i++) //lee los pulsos de los canales / Read the pulses of the channels
    {
 channel[i]=pulseIn(4, HIGH);
    }
    for(int i = 0; i <= channumber-1; i++) //Promedia los pulsos/Average the pulses
    {
 if((channel[i] > 2000) || (channel[i] <100))//Si se pasa del rango envia ultimo pulso/ If channel > max range, chage the value to the last pulse
 {
  channel[i]= lastReadChannel[i];
 }
 else
 {
 channel[i]=(lastReadChannel[i]+channel[i])/2; //Promedio el pulso pasado con el nuevo pulso/Average the last pulse eith the current pulse
 conta++; //Incrementa el contador/ increment counter
 }
    }

    }
    if(conta > filter)//Si el contador es mayor al filtro imprime valores/ If counter is > than filter, then prints values
    {
 for(int i = 0; i <= channumber-1; i++) //Ciclo para imprimir valores/Cycle to print values
 {
   Serial.print("CH"); //Canal/Channel
   Serial.print(i+1); // Numero del canal / Channel number
   Serial.print(": "); // que te importa
   Serial.println(channel[i]);
   lastReadChannel[i]=channel[i];
 }
 if(channel[4] > 1000) //si el canal 5 tiene un rango mayor a 500 enciende el LED/ If channel 5 is > than 500 turn on the led
 {
   digitalWrite(13, HIGH);
 }
 else
 {
   digitalWrite(13, LOW);//Si no lo apaga/If not turn it off
 }
 delay(400); //Delay
 conta=0;//Reinicia el contador/ Restart couter.
    }
  }

PPM Vs PWM
PPM and PWM are two different protocols for radio information. The PPM has the advantage that you can get all the channels information through one port only. Some call it PPM sum since it’s the sum of all channels. That helps a lot when you have limit number of connectors to your flightcontroller. So I will use PPM into my flight controller, and then the flight controller will use PWM outputs to the ESCs and to the servos for the camera mount.
By using the PPM input, I can now use 10 PWM outputs from my Open Pilot Copter Control instead of 6 PWM outputs. That is for obvious reasons essential for me, because my camera mount needs two servo outputs plus the 6 ESC outputs.

Como controlar un motor Brushless con Arduino. Tutorial

2011-12-28T23:14:00.002+01:00

A continuación explico con un pequeño tutorial, como controlar un motor Brushless con un variador de velocidad (ESC) y una placa Arduino o en mi caso, ArduPilotMega.

Necesitamos un batería LiPo, un ESC, un motor Brushless y un Arduino.

El esquema de conexión utilizado es el siguiente:

Para controlar un motor de este tipo hay que mandar al ESC señales como si quisiéramos controlar un servo normal. Estas señales son cuadradas con un tiempo en alto que varían entre 1 y 2 milisegundos, que correspondería a un águlo de entre 0 y 180 grados. Podemos probar primero con un servo: Si un servo no se mueve, el motor brushless nunca lo hará.

Para la conexión con el microcontrolador usaremos un pin de salida, en nuestro caso usaremos el pin 8. Si usamos ArduPilot Mega, este pin número 8 equivale al canal número 5 (CH_5). Conectamos el cable blanco al pin, el cable rojo, alimentación, queda libre y las tierras las unimos. (cable negro a GND del arduino)

Para conectar el ESC, le conectamos los cables de alimentación a la batería LiPo mediante un conector tipo banana de 4mm.(también podemos utilizar un fuente de alimentación externa, pero debemos de asegurarnos que tenga la potencia que el motor requiera.. que por lo general suele ser alta) Y para las conexiones del motor, en mi caso he soldado unas pinzas como se muestra en la figura. Importante amarrar bien el motor a una madera, ya que al arrancar puede ser peligroso y más si es un motor outrunner.

Para el código,importante armar el motor antes de arrancarlo, ya que si no lo hacemos no arrancará nunca. Para inicializar un motor basta con enviar señales de ángulo 0 hasta que el motor emita pitidos. Consiste en recibir un pulso de 1 milisegundo cada 20 milisegundos por un tiempo aproximado de 4 o 5 segundos.
El proceso es:

Alimentar el ESC y escuchar la música de confirmación.
Armar:

          myservo.write(0);   // Aramado

Esperar pitidos "Ready".
Mover el motor:

           myservo.write(pulsoMotor); //pulsoMotor lo variamos desde alrededor de 70 a 180 (máximo)

Notas:

Cada motor arranca con una señal de ángulo diferente, en mi caso está en 65º.
Si despues de armarlo envío señal de 70 directamente no arranca, hay que subir progresivamente. Basta con mandar un 30º y ya pasar a 70º.
Si queremos cambiar el sentido de giro al motor, intercambiando 2 de los 3 cables de motor es suficiente.

Descargar aquí el archivo con el CÓDIGO.

Para cualquier duda, sugerencia o opinión no dude en comentar.

Ventajas e inconvenintes: Tri, cuad, hexa y octo -cóptero.

2011-09-18T11:04:00.000+02:00

Según el uso que le queramos dar elegiremos el número de motores. En este caso la finalidad es la fotografía/vídeo aérea con cierta calidad. Las propiedades que queremos conseguir son:

Simplicidad y bajo peso en la estructura.
Capacidad de transportar una cámara de fotos reflex.
Fácilmente transportable y manejable.
Autonomía de unos 10 min..

Las posiblidades son: (todas la configuraciones de mikrokopter)

Configuraciones básicas:

Tricopter: Barato y fácil de construir, menos estable, partes móviles en la estructura (cola móvil por un servo), bajo empuje y menos tiempo de vuelo (porque los motores tienen que girar más rápido para mantenerlo en el aire).

Cuadricopter: Más simple mecánicamente que el tricopter. Posee 1/3 más de empuje pesando casi lo mismo y suelen ser más estables ya que no tienen partes móviles en la cola accionadas por un servo. Tienen más tiempo en vuelo debido a que pueden llevar baterías más grandes y a que los motores trabajan a menos revoluciones. Todavía no contamos con redundancia: Si un motor falla... cae.

Hexacopter: Todo lo bueno que tienen los cuadricópter pero con más potencia y más capacidad de carga. Posee algo de redundancia: Si pierde un motor todavía puede aterrizar, (perderíamos el control del ángulo 'yaw'). Como desventaja son más caros y más grandes.

Octocopter: Todo lo bueno que tienen los hexacópter más redundancia: Si pierde un motor todavía vuela bien. Se usa para asegurar cuando se ponen equipos fotográficos de alto precio. Son más caros que los hexacopter. Requieren mucha energía para volar.

Configuraciones compuestas:

Y6: se denomina Y6 a un tricóptero coaxial, es decir 2 motores en cada brazo montados en su mismo eje girando de forma contrapuesta. Funciona igual que un tricóptero, con cola móvil. Las diferencias con un tricóptero son dos: mayor capacidad de carga y redundancia.

Octo-coaxial: también denominado X8, es un cuadricóptero coaxial con ocho motores. Se consigue una buena redundancia y mayor capacidad de carga que con un cuadricóptero, pero menor que con un octocóptero radial debido al descenso de rendimiento en las hélices.

V8: la principal ventaja es la inmejorable panorámica para la fotografía aérea y su redundancia. . Está totalmente diseñado para la fotografía aérea y es un modelo patentado por Asctec, una empresa alemana, la cual comercializa este octocóptero, véase en la ilustración 8, y su precio oscila sobre unos 20 000 euros.

Monocóptero: caso bastante curioso, variante no válida para el uso que se le va a dar en este proyecto. El monocóptero gira sobre su propio eje, ver en la ilustración 9, y cuenta con un único motor en dirección tangente a la trayectoria. Para despegar necesitan de un soporte durante los primero giros hasta que se estabiliza. Su vuelo se asemeja a las semillas voladoras que producen algunos árboles.

Configuraciones en X y en +:

La configuración en o en se llaman así por la orientación de los motores delanteros con respecto al tren de aterrizaje y la placa de control. La diferencia entre las distintas configuraciones se puede observar en la ilustración. Para la fotografía es preferible la configuración en X, ya que nos deja la parte frontal más despejada.

Descartamos la opción de cuadricópter (quadricopter, quad... ) pora conseguir más capacidad de carga. Sobre la opción de elegir un hexacópter (hexacopter, hexa...) o octocóptero (octocopter, octo... ):

Ventajas de un mayor número de Motores:

Mayor capacidad de carga
No es necesario unos motores tan potentes o unas hélices tan grandes para la misma capacidad de carga.
Redundancia. Muy importante, en caso de rotura de una hélice, choque...

Como conclusion 6 motores es poco fiable, aunque, probablemente, sobreviviría a una parada de un motor, hay que irse a 8 motores para tener ambas cualidades: Capacidad de carga y Redundancia.

A mayor número de motores necesitaremos unas hélices más pequeñas, que dan una respuesta más rápida, resultando más estable. Por eso para conseguir estabilidad los motores/hélices han de poder cambiar de velocidad lo más rápidamente posible.

La configuración de seis motores es poco fiable, aunque, probablemente sobreviviría a una parada de un motor, habría que poner ocho motores para tener ambas cualidades: capacidad de carga y redundancia.

A mayor número de motores necesitaremos unas hélices más pequeñas, dan una respuesta más rápida, resultando más estable. Por eso para conseguir estabilidad los motores/hélices han de poder cambiar de velocidad lo más rápidamente posible.

Aunque con seis motores sea más eficiente en un 5 o 10% entre capacidad de carga y peso, elegiremos ocho sólo en el caso de necesitar incrementar la carga o la seguridad, ya que el precio se incrementa en un 30% por un mayor número de motores, ESCs y hélices.

Las configuraciones coaxiales consisten en colocar dos motores contrapuestos en un mismo eje. Tienen como principal ventaja la redundancia. Podemos usar las configuraciones Y6 o X8 equivalentes a un tricóptero y cuadricóptero respectivamente. Aunque son menos eficientes debido a que el aire que llega a la segunda hélice está ya turbulento.

Conclusión: si el objetivo es la fotografía tienes que irte a Hexa/octo, si el uso va a ser el pilotar una aeronave o las acrobacias lo más indicado es un cuadricóptero ligero.

Ver Multicópteros

Cuadricópteros

2011-07-04T02:26:00.000+02:00

Intro:

UAV (Unmanned Aerial Vehicle) como dicen sus siglas, es un vehículo aéreo no tripulado, ya sea totalmente autónomo, por control remoto, RPA (Remote Piloted Aircraft) o sistemas mixtos. Tradicionalmente se han usado con fines militares, pero actualmente se están desarrollando muchos otros usos civiles. Particularmente el uso con fines fotográficos me produce más interés.

Producción e investigación global: (UAV) (wikipedia)

The United States and Israel were initial pioneers in this technology, and U.S. manufacturers have a market share of over 60% in 2006, with U.S. market share due to increase by 5–10% through 2016. Israeli and European manufacturers form a second tier due to lower indigenous investments, and the governments of those nations have initiatives to acquire U.S. systems due to higher levels of capability. European market share represented just 4% of global revenue in 2006.

Multicóteros:

Un multicóptero es basicamente un helicótero pero con varios ejes y motores independientes. Existen tricópteros, cuadricópteros, hexacopteros, octocópteros... Tienen buena estabilidad y capacidad de carga. Las hélices giran en sentidos contraopuestos para evitar que gire sobre su propio eje de forma continuada debido a la inercia de las hélices. El control se lleva a cabo con una placa electrónica central que varía la velocidad de giro de cada motor independientemente, así se consiguen todos los movimientos posibles.

Usos no militares:

Vigilancia aérea de grandes superficies mediante sistemas UAV low cost.
Trasporte de bienes.
Investigación científica: Sensado remoto, vehículos equipados con sensores de cualquier tipo: espectro electromagnético, sensores biológicos, químicos...
Búsqueda y rescate en catástrofes naturales.
Otros fines comerciales como la fotografía y video aéreo. Como es el caso de Jeff Scholl, un americano que se dedica a la fotografia aérea profesionalmente. Su facebook. Tiene fotos y videos realmente impresionantes.

www.gravityshots.com

Algunos de los aparatos que usa Jeff Scholl para sus grabaciones son:

Alguno de sus videos:

Para poder grabar con estabilidad necesitamos un estabilizador Nick and Roll compensation:

Con dos servos y unos amortiguadores del tipo rubber dampeners, dampeners2 reduciremos las vibraciones procedentes de los motores.

Desde la universidad de Pennsylvania, el GRASP Lab està trabajando en movimientos avanzados para quadricópeteros autónomos, aqui muestro algunos de sus videos:

En el siguiente video podemos ver un equipo de cuadricópteros cooperando para construir el marco de una pequeña estructura, un pequeño ejemplo del gran potencial que pueden llegar a tener estos ingeniosos aparatos en diversas tareas:

Ver Multicópteros