Como construir una maquina CNC a partir de piezas recicladas


A veces las partes viejas de ordenadores pueden ser muy útiles para muchas cosas pero sobre todo es muy destacable    las fuentes de alimentación (tanto de portátiles como  de ordenadores fijos )  de las que tantas veces hemos hablado en este blog , no solo para  usar la salidas de 12 y 5V , sino incluso para hacer asociaciones de  varias fuentes  para generar fuentes con tensiones o intensidades mayores .
El reciclaje de las piezas de un ordenador  no queda en la fuente,  pues hay un sinfín de  otras piezas  útiles  que podemos  reciclar en un viejo ordenador, como por ejemplo:
  •  Las pantallas de los portátiles  que  pueden usarse  con una controladora barata como un  monitor.
  • Las memorias  que pueden utilizarse para otros aparatos electrónicos.
  • Los ventiladores  y radidadores  usados para refrigerar las CPU  nos pueden servir para refrigerar nuestros circuitos o  incluso para otras aplicaciones con celulas de Peltier
  •  Las cajas ATX  tienen un sinfín de aplicaciones
  • De los lectores de CD / DVD podemos usar los motores,la mecánica  y el láser
  • De las viejas disqueteras   podemos usar los motores,la mecánica
  • Tornillos , herrajes ,etc

En el post de hoy a vamos a  ver como es posible construir una maquina  CNC o una impresora 3D     con la mecánica  de dos  o tres lectores dvd ( o incluso incluyendo una disquetera) invirtiendo muy poco dinero, pues tan solo necesitaríamos una mínima  electronica de control aparte.

Las partes hardware que necesitamos son:
  •  3 lectores de CD o DVD que no usemos
  • 1 Arduino (Uno en nuestro caso)
  • 3 controladras de motor paso  a paso
  • Fuente de alimentación  de 5v DC ( nos vale una vieja fuente de PC)
El sofware necesario seria el siguiente:

Ensamblaje

Para empezar  con este proyecto  lo primero  es desmontar  los  lectores de CD o DVD
disco1
Como vemos  ,en su interior vamos a ver encontrar una placa  metálica con un motor paso paso (compuesto por  dos bobinados independientes ) y cuyo eje es un tornillo sin  fin , lo cual es la pieza clave  para   reciclar . Asimismo necesitaremos las carcasas de dos de ellas  y los componentes necesarios para fijarlos al chasis (  el laser  y los otros motores no son necesarias).
Cada motor va a simular cada uno de los ejes de la maquina (X,Y,Z)  por los que en los contactos de cada motor  soldaremos un cablecillo  a cada contacto para hacer las 4  conexiones  con las controladoras ( podemos eliminar el cable de cinta flexible que suelen llevar pues es muy difícil que den la medida).
En este punto es interesante identificar mediante una sencilla de prueba de continuidad con un polímetro   usándolo en modo  resistencia  para  saber cuales son los dos bobinados  ( entre si   no deben tener continuidad )
 cables.JPG
Una vez tengamos el cableado hecho de los motores nos tocaría la parte mecánica la cual quizás sea la parte mas engorrosa  y difícil de llevar a cabo   pues realmente no existe una única solución  a este problema   a la hora de afrontar el ensamblaje  que básicamente  consiste en  fijar los carros con  los motores paso a paso en los tres ejes x, y , z  para formar un único conjunto.
En primer  lugar  , nos centraremos en lo que será el eje Y  . Usando  una carcasa colocaremos uno de los  carros junto con el motor  por medio de  soportes tratando de alinearlo lo mas cercano a uno de los bordes  y centrándolo sobre este.
Los soportes pueden ser metálicos roscados ( se pueden comprar en ferreterias)  o separadores de plástico de los usadas para las placas madre.
ejey
De un modo similar  también fijaremos otro carro con su motor a otras de las carcasas de manera que crearemos para el eje X (obviamente la idea  es montarlo perpendicularmente al montaje del eje y). Asimismo también debemos fijarlos  a una de los bordes en la parte superior y centrados sobre este cuerpo.
Los soportes usados también  pueden ser metálicos roscados ( se pueden comprar en ferreterias)  o separadores de plástico de los usadas para las placas madre.
ejex.png
Ahora nos toca el eje z  que se diferencia   de los dos anteriores  que debe ir colocado sobre  uno de los ejes: más  concretamente el eje x.
El eje Z a diferencia de los otros dos lo instalaremos en una placa  liviana ( por ejemplo de vaquelita ,plástico, metílica,etc  ) para luego  montarla en los soportes del eje X
ejez.png
Una vez que tenemos los tres ejes es hora de  unir  ambas carcasa  por  las  base del eje Y y X  formando un angulo recto.
Normalmente muchos aficionados usan escuadras metálicas   e incluso pequeños perfiles metálicos entre ambas carcasas  : todo depende de lo solido que haya quedado la unión así que  quizás  no sea tan necesario en función de como queden fijadas ambas partes
escuadras1.png
Una vez que hayamos ensamblados  lso tres ejes , nuestro proyecto ha tomando toda su  forma, por  lo que solo nos queda conectar  los motores paso a paso a  los controladores   y estos a la placa Arduino Uno.
Las conexiones de cada motor irán a cada driver  de motor  paso  a paso y las entradas  de estos  a la placa Arduino Uno según las siguientes  conexiones digitales:
  • Eje x: puertos 3 y 6, GND
  • Eje Y : puertos 4 y 7,GND
  • Eje Z: puertos 5 y  8;GND

Asimismo no debemos olvidar las conexiones de alimentacion de la placas de los drivers (+5V) que se recomienda no se obtengan de Arduino  sino directamente desde  la fuente auxiliar

El esquema electrico final seria el  siguiente:
Diagramas
Cuando hayamos  conectado e instalado, lo que quedaría seria ir configurando el software necesario para hacerla funcionar.
En youtube podemos encontrar  miles de videotutoriales  que explican con detalles estos pasos por lo que no lo vamos a repetir aquí
Como pinceladas  dejamos dos vídeos muy claros al respecto para que sirvan  como guía:
Con eso concluimos  de este proyecto, lo cual es la base para diferentes usos como puede ser un plotter , una fresadora o incluso colocando un extrusor una impresora 3D,una grabadora láser , etc
final.png
Anuncios

Plataforma de sensores e-Health V1.0 para Arduino y Raspberry Pi [aplicaciones biométricas / medicina]


En agosto de 2013 Cooking Hacks lanzó la nueva versión del primer escudo biométrica para Arduino y Raspberry Pi: la plataforma  e-Health Sensor. Gracias a la retroalimentación de la comunidad y varios proyectos que han sido creados con esta, han mejorado la plataforma de e-Health con nuevas características tales como:

  • Nuevo sensor de músculo
  • Sensor de presión de la sangre nueva
  • Glucómetro actualizado
  • Nuevas posibilidades de conexión

En este post  vamos a explicar cómo trabajar cplataforma  e-Health Sensor.V2.0.

E-Health Sensor Shield V2.0 permite a los usuarios de Arduino y Raspberry Pi realizar aplicaciones biométricas y médicas donde la supervisión del cuerpo sea necesaria mediante el uso de 10 sensores diferentes: pulso, oxígeno en sangre (SPO2), flujo de aire (respiración), temperatura corporal, Electrocardiograma (ECG), glucómetro, respuesta galvánica de la piel (GSR – sudoración), presión arterial (esfigmomanómetro), posición del paciente (acelerómetro) y sensor de músculo/eletromyography (EMG).

Esta información puede utilizarse para monitorizar en tiempo real el estado de un paciente o para obtener datos sensibles para ser analizados posteriormente para el diagnóstico médico. La información biométrica obtenida puede enviarse sin cables usando cualquiera de las 6 opciones de conectividad: Wi-Fi, 3 G, GPRS, Bluetooth, 802.15.4 y ZigBee dependiendo de la aplicación.

Si para  el diagnóstico de la imagen en tiempo real es necesaria una cámara puede conectarse el módulo 3G para enviar fotos y videos del paciente a un centro de diagnóstico médico.

Los datos pueden enviarse a la nube para almacenamiento permanente o visualizarlos en tiempo real enviando los datos directamente a un ordenador portátil o Smartphone. También  hay desarrollado  varias aplicaciones iPhone y Android  para poder ver fácilmente la información del paciente.

La privacidad es uno de los puntos clave en este tipo de aplicaciones. Por esta razón, la plataforma incluye varios niveles de seguridad:

    • En la capa de enlace de comunicación: AES 128 para 802.14.5 / ZigBee y WPA2 para Wifi.
    • En la capa de aplicación: mediante el protocolo HTTPS (seguro) nos aseguramos de un túnel de seguridad de punto a punto entre cada nodo de sensor y el servidor web (este es el mismo método utilizado en las transferencias bancarias).

e-Health protector del Sensor sobre Arduino (izquierda) frambuesa Pi (derecha)

Importante: La plataforma de e-Health Sensor ha sido diseñada por Cooking Hacks (la división de hardware abierto de Libelium) para ayudar a los investigadores, desarrolladores y artistas para medir datos de sensor biométrico para fines de experimentación, diversión y prueba proporcionando una alternativa barata y abierta en comparación con las soluciones propietarias  debido al precio prohibitivo de llas profesionales usadas por el  mercado médico. Precisamente por esta razon, como la plataforma no tiene certificaciones médicas no puede  ser utilizada para monitorizar pacientes críticos que necesitan un control médico preciso o aquellos cuyas condiciones deben medirse con precisión para un diagnóstico profesional ulterior.
Gracias a la comunidad Arduino y Raspberry  Pi ,es  posible  una rápida prueba de concepto y servir de  base de una nueva era de productos médicos de código abierto.

El paquete que vamos a utilizar en este tutorial se basa en la plataforma de Sensor de eHealth de Cooking Hacks. La E-Health protector del Sensor es totalmente compatible con las nuevas y viejas versiones de Arduino USB, Duemilanove y Mega y Rsapberry.

  • 8 sensores médicos no invasiva + 1 invasoras
  • Almacenamiento y uso de las mediciones de glucosa.
  • Monitoreo de señales ECG.
  • Señales de monitorización EMG.
  • Control de flujo de aire del paciente.
  • Control de flujo de aire del paciente.
  • Datos de la temperatura del cuerpo.
  • Medidas de respuesta galvánica de la piel.
  • Detección de la posición del cuerpo.
  • Funciones de pulso y oxígeno.
  • Dispositivo de control de la presión arterial.
  • Múltiples sistemas de visualización de datos.
  • Compatible con todos dispositivos UART.

Características eléctricas:

La placa puede ser alimentada por el PC o por una fuente externa. Algunos de los puertos USB en los ordenadores no son capaces de dar toda la corriente para que el módulo pueda  trabajar, si el módulo tiene problemas cuando funcione, se puede utilizar una fuente externa (12V – 2A) en el Arduino/RasberryPi

El escudo

 

Escudo de e-Health sobre Raspberry Pi

Para conectar el protector del Sensor e-Health para Raspberry Pi es necesario un  adaptador que haga de puente de conexión .

La idea detrás del  puente de conexión Arduino shields es permitir utilizar cualquiera de los escudos, placas y módulos diseñados para Arduino en Raspberry Pi. También incluye la posibilidad de conectar sensores analógicos y digitales, utilizando el mismo pinout de Arduino pero con la potencia y capacidades de Raspberry Pi

La conexión puente es compatible con Raspberry Pi, Raspberry Pi (modelo B +), Raspberry Pi 2 y el Raspberry Pi 3.

Para hacer completa la compatibilidad han creado la biblioteca de arduPi que permite el uso de frambuesa con el mismo código utilizado en Arduino. Para ello, han implementado funciones de conversión de modo que usted puede controlar de la misma manera como en Arduino la entrada-salida interfaces: i2C, SPI, UART, analógica, digital, en Raspberry Pi.

Vamos a resumir lo que podemos hacer con este escudo junto con la biblioteca de arduPi:

ADVERTENCIAS:

  • Los módulos LCD, esfigmomanómetro y comunicación utilizan el puerto UART y no pueden trabajar al mismo tiempo.
  • El glucómetro es ahora compatible con otros dispositivos UART y tiene su propio conector. Pero no puede trabajar con el esfigmomanómetro conectado.
  • El sensor de EMG y el ECG no pueden trabajar al mismo tiempo. Utilizar los puentes integrados en el tablero para utilizar uno u otro
  • Para utilizar el sensor de EMG, usted tiene que tener los puentes en la posición de EMG. Para utilizar el sensor de ECG, usted tiene que tener los puentes en la configuración de ECG.

El escudo

Versión 2 del escudo:

  • Esta versión incluye un conmutador Digital para activar/desactivar la toma de corriente para módulos inalámbricos usando GPIO23 (Digital Pin 3).

Versión 1 del escudo:

  • 8 pines digitales.
  • Conector para módulos inalámbricos.
  • Pernos de RX/TX.
  • pasadores de i2C (SDA, SCL).
  • Pasadores de SPI (SCK MISO, MOSI, CS). Puede utilizarse también como GPIO.
  • 8 canales convertidor analógico a digital.
  • Interruptor para activar la fuente de alimentación externa.

 La biblioteca: arduPi

arduPi es una librería C++ que permite escribir programas para Raspberry Pi como si estuvieras escribiendo un programa de arduino. Todas las funciones para el control de comunicaciones del puerto serie, i2C, SPI y GPIO pins están disponibles mediante la sintaxis de arduino.

arduPi ha sido probado en una distribución Raspbian. Para grabar una imagen de Raspbian a la tarjeta SD se pueden descargar los NOOBS aquí y siga estas instrucciones.

Una vez instalado Raspbian, descargue e instale arduPi biblioteca en una carpeta nueva, por ejemplo: “página de inicio/pi/ardupi”

Para Rasberry Pi:

wget http://www.cooking-hacks.com/media/cooking/images/documentation/raspberry_arduino_shield/raspberrypi.zip && unzip raspberrypi.zip && cd cooking/arduPi && chmod +x install_arduPi && ./install_arduPi && rm install_arduPi && cd ../..
Para Raspberry Pi 2 y 3:
wget http://www.cooking-hacks.com/media/cooking/images/documentation/raspberry_arduino_shield/raspberrypi2.zip && unzip raspberrypi2.zip && cd cooking/arduPi && chmod +x install_arduPi && ./install_arduPi && rm install_arduPi && cd ../..

Descargar arduPi biblioteca para Raspberry Pi

Descargar biblioteca de arduPi de frambuesa Pi 2 y 3

Usted puede encontrar una biblioteca de cambios aquí.

Funciones generales de Arduino:

  • Delay()
  • delayMicroseconds()
  • Millis()
  • pinMode()
  • digitalWrite()
  • digitalRead()
  • analogRead() (en pines de A0 a A7. Ejemplo: analogRead(5) leerá A5)
  • shiftIn()
  • shiftOut()
  • attachInterrupt() *
  • detachInterrupt()

[*] Podemos detectar interrumpe el ascenso y descenso. Cualquier pin digital (de 2 a 13) puede ser utilizado en attachInterrupt(). Por ejemplo, si queremos estar al tanto de eventos de levantamiento en el pin 6 que podemos hacer attachInterrupt(6,function_to_call,RISING).

Biblioteca  serie:

  • available()
  • begin()
  • end()
  • Flush()
  • Peek()
  • Print()
  • println()
  • Read()
  • readBytes()
  • readBytesUntil()
  • Find()
  • findUntil()
  • parseInt()
  • parseFloat()
  • setTimeout()
  • Write()

Biblioteca wire:

  • begin()
  • requestFrom()
  • beginTransmission()
  • endTransmission()
  • Write()
  • Read()

Biblioteca SPI:

  • begin()
  • end()
  • setBitOrder()
  • setClockDivider()
  • setDataMode()
  • Transfer()

Uso de la biblioteca arduPi:

En la carpeta de biblioteca encontrarás 3 archivos: arduPi.cpp, arduPi.h y arduPi_template.cpp
el archivo arduPi_template.cpp está destinado a ser utilizado como punto de partida para crear programas con el mismo comportamiento como un programa de arduino.

Aquí puede ver el código de plantilla:

//Include arduPi library
    #include "arduPi.h"

    /*********************************************************
     *  IF YOUR ARDUINO CODE HAS OTHER FUNCTIONS APART FROM  *
     *  setup() AND loop() YOU MUST DECLARE THEM HERE        *
     * *******************************************************/

    /**************************
     * YOUR ARDUINO CODE HERE *
     * ************************/

    int main (){
        setup();
        while(1){
            loop();
        }
        return (0);
    }

Como se puede ver en la función main() la función setup() es llamada una vez y luego la función loop() se llama contínuamente hasta que el programa se ve obligado a terminar.

Ya sea si están empezando a escribir un nuevo programa, o si usted tiene un programa de arduino escrito que utiliza las funciones portadas puede utilizar la plantilla (ardupi_template.cpp) y poner el código de arduino donde dice: el código de ARDUINO aquí. Recuerde que el programa que está escribiendo un programa C++ para que todas las bibliotecas de C++ pueden utilizarse.

También recordar, como se puede leer en la plantilla que si el código de arduino utiliza otras funciones setup() y loop() debe declararlos en el área indicada.

 Habilitación de Interfaces:

Los siguientes pasos han sido probados con Raspbian Jessie: 4.4.9 (Linux versión 4.4.9-v7+ ([email protected]) (gcc versión 4.9.3 (crosstool-NG crosstool-ng-1.22.0-88-g8460611)) #884 SMP el viernes 6 de mayo 17:28:59 BST 2016)

Raspberry Pi 2:

  • Abrir un terminal en la Raspberry Pi, o conecte al Raspberry Pi a través de SSH.
  • Abra el archivo /boot/config.txt: sudo nano /boot/config.txt
  • Agregue las líneas siguientes al archivo:
#enable uart interface
enable_uart=1

#enable spi interface
dtparam=spi=on

#enable i2c interface
dtparam=i2c_arm=on
  • Presione CTRL + X para salir y guardar el archivo.
  • Actualizar el sistema operativo con los últimos parches.
sudo apt-get update
sudo apt-get upgrade
  • Reiniciar la Raspberry Pi.
sudo reboot

Raspberry Pi 3:

  • Abrir un terminal en la Raspberry Pi, o conecte al Raspberry Pi a través de SSH.
  • Abra el /boot/config.txt archivo <:sudo nano /boot/config.txt
  • Agregue las líneas siguientes al archivo:
#map mini-UART to internal bluetooth an free-up main UART to handle CookingHacks modules
dtoverlay=pi3-miniuart-bt

#enable uart interface
enable_uart=1

#enable spi interface
dtparam=spi=on

#enable i2c interface
dtparam=i2c_arm=on
  •  Presione CTRL + X para salir y guardar el archivo.
  • Abra el archivo /boot/cmdline.txt:sudo nano /boot/cmdline.txt
  • Este archivo contiene algo similar a esto (el contenido puede variar):
dwc_otg.lpm_enable=0 console=ttyAMA0,115200 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline rootwait
  • Eliminar los parámetros que hacen referencia al puerto serie UART (ttyAMA0):
dwc_otg.lpm_enable=0  console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline rootwait ip=192.168.1.160:::255.255.255.0
  • Presione CTRL + X para salir y guardar el archivo.
  • Actualizar el sistema operativo con los últimos parches.
sudo apt-get update
sudo apt-get upgrade
  • Reiniciar la Raspberry Pi.
sudo reboot
    

Ejecución de su programa

Para ejecutar el programa debe tener los permisos adecuados para utilizar GPIO (/ dev/mem debe accederse en la frambuesa). Puede ejecutar el programa con sudo:

sudo ./MY_PROGRAM

 Circuitos básicos.

ADVERTENCIA: los niveles de voltaje GPIO 3.3 V y no 5 V tolerantes. No hay ninguna protección de sobretensión en el tablero. Entradas digitales utilizan un nivel de lógica de 3V3 y no son tolerantes de niveles 5V, como se podría encontrar en un Arduino 5V alimentado.Tenga extrema precaución cuando trabaje con GPIO, puede dañar su Raspberry Pi, su equipo y potencialmente a sí mismo y otros. Si lo hace es bajo su propio riesgo!

4.1 GPIO de entrada

Periféricos GPIO varían bastante. En algunos casos, son muy simples, por ejemplo un grupo de pines pueden activarse como un grupo a la entrada o salida. Los voltajes de entrada y de salida son por lo general limitado a la   tensión de alimentación del dispositivo con los GPIOs por lo que pueden resultar dañados por una mayor tensión.

Algunos GPIOs tienen 5 entradas tolerantes V: incluso en los voltajes de la fuente baja, el dispositivo puede aceptar 5V sin daño.

Para Raspberry Pi, presentamos un ejemplo de cómo adaptar el nivel de voltaje de una medida de sensor de 5V para evitar posibles daños.

Componentes para este ejemplos y circuito de adaptación de tensión pueden fundados en el Starter Kit para Raspberry Pi.

Cuando un pin GPIO se configura como una entrada con un ejemplo de botón básico, podemos tener estos problemas de incompatibilidad de voltajes.

Este circuito es malo porque cuando usted presiona el botón de la entrada GPIO está conectada a 5 voltios, por lo tanto nuestro dispositivo puede dañarse.

Sin embargo, esto puede evitarse utilizando simplemente una resistencia en el cable del pulsador. El valor de la resistencia se determina por la corriente de la salida de los pines GPIO (la corriente por el circuito solía para leer el pin) y la cantidad de caída de voltaje que crea como resultado de ello. Con el resistor de 5K se obtiene 3, 3V en lo GPIO de entrada.

Vgpio = 5V· (10K/(10K+5K)) = 3, 3V

 medición del Sensor GPIO

Tenemos el mismo problema si utilizamos un sensor funcionando a 5 voltios.

Aquí está un ejemplo usando un sensor PIR.

Como se muestra en la imagen, utilizamos el mismo divisor resistivo utilizado para adaptar el nivel de tensión.

 ADC.

El escudo incluye a un ADC de 12b de la resolución que permite para conectar cualquier sensor a frambuesa con mayor precisión que Arduino. La comunicación entre la Raspberry Pi  y el ADC del escudo se realiza vía i2C.

La información de cada canal se puede obtener dos bytes de lectura de i2C, pero previamente un byte (que corresponde a la dirección de canal) debe enviar a través de i2C dependiendo del canal que queremos seleccionar. Aquí está una lista con las direcciones de canal:

Canal Dirección
0 0xDC
1 0x9C
2 0xCC
3 0x8C
4 0xAC
5 0xEC
6 0xBC
7 0xFC

Veremos un ejemplo de un programa que lee cada canal continuamente esperando 5 segundos entre repeticiones.

Con un cable de conexión el pin de 5V con algunos de los pines del ADC un valor cerca de 5.000000 debe leerse.

Todos los ejemplos en esta guía utilizan la biblioteca arduPi

//Include arduPi library 
#include "arduPi.h" 

char selected_channel[1];
char read_values[4];

int channel_0 = 0; 
int channel_1 = 0; 
int channel_2 = 0; 
int channel_3 = 0; 
int channel_4 = 0; 
int channel_5 = 0; 
int channel_6 = 0; 
int channel_7 = 0; 

float analog_0 = 0.0; 
float analog_1 = 0.0; 
float analog_2 = 0.0; 
float analog_3 = 0.0; 
float analog_4 = 0.0; 
float analog_5 = 0.0; 
float analog_6 = 0.0; 
float analog_7 = 0.0; 

void setup() 
{ 
  Wire.begin(); // join i2C bus (address optional for master) 
} 

void loop() 
{ 
  // channel 0 
  Wire.beginTransmission(8); 
  selected_channel[0] = 0xDC;
  Wire.read_rs(selected_channel, read_values, 2);
  Wire.read_rs(selected_channel, read_values, 2);
  channel_0 = int(read_values[0])*16 + int(read_values[1]>>4); 
  analog_0 = channel_0 * 5.0 / 4095.0;
  printf("Channel 0:\n");
  printf("Digital value = %d / Analog value = %fV\n\n", channel_0, analog_0); 


  // channel 1 
  Wire.beginTransmission(8); 
  selected_channel[0] = 0x9C;
  Wire.read_rs(selected_channel, read_values, 2);
  Wire.read_rs(selected_channel, read_values, 2);
  channel_1 = int(read_values[0])*16 + int(read_values[1]>>4); 
  analog_1 = channel_1 * 5.0 / 4095.0;
  printf("Channel 1:\n");
  printf("Digital value = %d / Analog value = %fV\n\n", channel_1, analog_1); 
  
 
  // channel 2 
  Wire.beginTransmission(8); 
  selected_channel[0] = 0xCC;
  Wire.read_rs(selected_channel, read_values, 2);
  Wire.read_rs(selected_channel, read_values, 2);
  channel_2 = int(read_values[0])*16 + int(read_values[1]>>4); 
  analog_2 = channel_2 * 5.0 / 4095.0;
  printf("Channel 2:\n");
  printf("Digital value = %d / Analog value = %fV\n\n", channel_2, analog_2); 
  
  
  // channel 3 
  Wire.beginTransmission(8); 
  selected_channel[0] = 0x8C;
  Wire.read_rs(selected_channel, read_values, 2);
  Wire.read_rs(selected_channel, read_values, 2);
  channel_3 = int(read_values[0])*16 + int(read_values[1]>>4); 
  analog_3 = channel_3 * 5.0 / 4095.0; 
  printf("Channel 3:\n");
  printf("Digital value = %d / Analog value = %fV\n\n", channel_3, analog_3); 
  
  
  // channel 4 
  Wire.beginTransmission(8); 
  selected_channel[0] = 0xAC;
  Wire.read_rs(selected_channel, read_values, 2);
  Wire.read_rs(selected_channel, read_values, 2);
  channel_4 = int(read_values[0])*16 + int(read_values[1]>>4); 
  analog_4 = channel_4 * 5.0 / 4095.0; 
  printf("Channel 4 (vertical header):\n");
  printf("Digital value = %d / Analog value = %fV\n\n", channel_4, analog_4); 
  
  
  // channel 5 
  Wire.beginTransmission(8); 
  selected_channel[0] = 0xEC;
  Wire.read_rs(selected_channel, read_values, 2);
  Wire.read_rs(selected_channel, read_values, 2);
  channel_5 = int(read_values[0])*16 + int(read_values[1]>>4); 
  analog_5 = channel_5 * 5.0 / 4095.0; 
  printf("Channel 5 (vertical header):\n");
  printf("Digital value = %d / Analog value = %fV\n\n", channel_5, analog_5); 
  
  
  // channel 6 
  Wire.beginTransmission(8); 
  selected_channel[0] = 0xBC;
  Wire.read_rs(selected_channel, read_values, 2);
  Wire.read_rs(selected_channel, read_values, 2);
  channel_6 = int(read_values[0])*16 + int(read_values[1]>>4); 
  analog_6 = channel_6 * 5.0 / 4095.0; 
  printf("Channel 6 (vertical header):\n");
  printf("Digital value = %d / Analog value = %fV\n\n", channel_6, analog_6); 
  
  
  // channel 7 
  Wire.beginTransmission(8); 
  selected_channel[0] = 0xFC;
  Wire.read_rs(selected_channel, read_values, 2);
  Wire.read_rs(selected_channel, read_values, 2);
  channel_7 = int(read_values[0])*16 + int(read_values[1]>>4); 
  analog_7 = channel_7 * 5.0 / 4095.0;
  printf("Channel 7 (vertical header):\n");
  printf("Digital value = %d / Analog value = %fV\n\n", channel_7, analog_7); 
  
  
  printf("***********************************\n"); 



  delay(1000); 

} 


int main (){ 
    setup(); 
    while(1){ 
        loop(); 
    } 
    return (0); 
}
                

Aquí está la salida de este programa que se conecta al pin de 5V de la Raspberry  Pia la entrada analógica 0:

UART.

Acceso al UART con arduPi biblioteca es tan simple como hacerlo con Arduino.

Necesita incluir arduPi.h en el código y crear una instancia de clase SerialPi nombrarlo serie.

Nombre de la instancia como serie le permite utilizar la sintaxis de arduino. (Todo esto está ya hecho si utilizas la plantilla proporcionada para crear sus programas).

Las funciones disponibles son:

  • Serial.Available()
  • Serial.Begin()
  • Serial.end()
  • Serial.Flush()
  • Serial.Peek()
  • Serial.Print()
  • Serial.println()
  • Serial.Read()
  • Serial.readBytes()
  • Serial.readBytesUntil()
  • Serial.Find()
  • Serial.findUntil()
  • Serial.parseInt()
  • Serial.parseFloat()
  • Serial.setTimeout()
  • Serial.Write()

Todas estas funciones tienen la misma funcionalidad que el arduino unos. Puede encontrar más información en:http://Arduino.CC/en/Reference/serial

Un ejemplo de código que se pueden encontrar en el tutorial de frambuesa Pi XBee acess el UART

 i2C.

Un ejemplo de uso de i2C puede encontrarse en la sección de ADC .

Aquí mostramos otro ejemplo usando lo BlinkM RGB i2C controlado dirigido.

BlinkM utiliza una alta calidad, poder más elevado LED RGB y un pequeño Microcontrolador AVR para permitir que un usuario de una interfaz i2C simple digital control de un LED RGB.

En el ejemplo vamos a cambiar el color led usando fade transiciones y también cambiando directamente. Más información sobre lo LED y los comandos que podemos enviar a él puede encontrarse en la hoja de datos.

Conectar la clavija (-) del led con el pin GND del escudo.

Conecta (+) del pin del led con el pin de 5V de la pantalla.

Conectar la clavija d del led con el pin SDA del escudo.

Conectar la clavija c del led con el pin SCL del escudo.

Aquí está el código:

/*  
 *  Raspberry Pi to Arduino Shields Connection Bridge
 *  
 *  Copyright (C) Libelium Comunicaciones Distribuidas S.L. 
 *  http://www.libelium.com 
 *  
 *  This program is free software: you can redistribute it and/or modify 
 *  it under the terms of the GNU General Public License as published by 
 *  the Free Software Foundation, either version 3 of the License, or 
 *  (at your option) any later version. 
 *  a
 *  This program is distributed in the hope that it will be useful, 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
 *  GNU General Public License for more details.
 *  
 *  You should have received a copy of the GNU General Public License 
 *  along with this program.  If not, see http://www.gnu.org/licenses/. 
 *  
 *  Version:           2.0
 *  Design:            David Gascón 
 *  Implementation:    Jorge Casanova & Luis Martín
 */


//Include arduPi library
#include "arduPi.h"


void setup(){
    Wire.begin();
    Wire.beginTransmission(9);
    Wire.write('o'); //End the current Light script
    Wire.endTransmission();
}

void loop(){
    for (int i=0;i < 5;i++){
        Wire.beginTransmission(9);
        Wire.write('n'); //Change to color
        Wire.write(byte(0xff)); //Red component
        Wire.write(byte(0x00)); //Green component
        Wire.write(byte(0x00)); //Blue component
        Wire.endTransmission();

        delay(500);
        
        Wire.beginTransmission(9);
        Wire.write('n'); //Change to color
        Wire.write(byte(0x00)); //Red component
        Wire.write(byte(0x00)); //Green component
        Wire.write(byte(0xff)); //Blue component
        Wire.endTransmission();
        
        delay(500);
    }
    
    for (int i=0;i < 10;i++){
        Wire.beginTransmission(9);
        Wire.write('c'); //Fade to color
        Wire.write(byte(0xff)); //Red component
        Wire.write(byte(0x00)); //Green component
        Wire.write(byte(0x5a)); //Blue component
        Wire.endTransmission();

        delay(150);
        
        Wire.beginTransmission(9);
        Wire.write('c'); //Fade to color
        Wire.write(byte(0x55)); //Red component
        Wire.write(byte(0x20)); //Green component
        Wire.write(byte(0x5a)); //Blue component
        Wire.endTransmission();

        delay(150);
    }
}

int main (){
    setup();
    while(1){
        loop();
    }
    return (0);
}

Este código alternativo de rojo a azul cinco veces y luego hacer unas transiciones suaves entre colores violáceos.

 SPI.

Es posible comunicar con dispositivos SPI usando las funciones arduPi.

En este ejemplo utilizamos las funciones SPI para imprimir mensajes en la ST7920 LCD12864 (LCD SPI)

En primer lugar, tenemos que poner el interruptor de la pantalla LCD en modo SPI.

Ahora procedemos con la conexión entre el LCD y el Raspberry Pi a arduino shield:

VCC de la LCD a 5v del escudo

GND de la LCD a GND del escudo

SCK de lo LCD a SCK del escudo

SID de la LCD a MOSI del escudo

CS de la pantalla LCD al pin 8 del escudo

Como puedes ver estamos utilizando el número pin 8 del escudo frambuesa Pi como chip select. Así que cuando tenemos que seleccionar la pantalla LCD como el dispositivo de destino para la comunicación SPI tenemos poner el pin 8 a alta.

Aquí está el código

/*  
 *  Raspberry Pi to Arduino Shields Connection Bridge
 *  
 *  Copyright (C) Libelium Comunicaciones Distribuidas S.L. 
 *  http://www.libelium.com 
 *  
 *  This program is free software: you can redistribute it and/or modify 
 *  it under the terms of the GNU General Public License as published by 
 *  the Free Software Foundation, either version 3 of the License, or 
 *  (at your option) any later version. 
 *  a
 *  This program is distributed in the hope that it will be useful, 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
 *  GNU General Public License for more details.
 *  
 *  You should have received a copy of the GNU General Public License 
 *  along with this program.  If not, see http://www.gnu.org/licenses/. 
 *  
 *  Version:           2.0
 *  Design:            David Gascón 
 *  Implementation:    Jorge Casanova & Luis Martín
 */

//Include arduPi library
#include "arduPi.h"

int latchPin = 8;
unsigned char char1[]=" Cooking Hacks  ";
unsigned char char2[]="  SPI LCD for   ";
unsigned char char3[]="  Raspberry Pi  ";

void initialise();
void displayString(int X,int Y,unsigned char *ptr,int dat);
void writeCommand(int CMD);
void writeData(int CMD);
void writeByte(int dat);
void clear();

void setup(){
    SPI.begin();
    SPI.setBitOrder(MSBFIRST);
    SPI.setDataMode(SPI_MODE0);
    SPI.setClockDivider(SPI_CLOCK_DIV128);

    initialise();
}

void loop(){
    displayString(0,0,char1,16);
    delay(2000);
    clear();
    displayString(1,0,char2,16);
    displayString(2,0,char3,16);
    delay(2000);
    clear();
}

void initialise(){
    pinMode(latchPin, OUTPUT);     
    digitalWrite(latchPin, LOW);

    delayMicroseconds(80);

    writeCommand(0x30);
    writeCommand(0x0c);
    writeCommand(0x01);
    writeCommand(0x06);
}


void displayString(int X,int Y,unsigned char *ptr,int dat){
    int i;

    switch(X){
        case 0:  Y|=0x80;break;

        case 1:  Y|=0x90;break;

        case 2:  Y|=0x88;break;

        case 3:  Y|=0x98;break;

        default: break;
    }

    writeCommand(Y);

    for(i=0;i < dat;i++){ 
        writeData(ptr[i]);
    }

}

void writeCommand(int CMD){
    int H_data,L_data;
    H_data = CMD;
    H_data &= 0xf0;
    L_data = CMD;
    L_data &= 0x0f;
    L_data <<= 4;
    writeByte(0xf8);
    writeByte(H_data);
    writeByte(L_data);
}

void writeData(int CMD){
    int H_data,L_data;
    H_data = CMD;
    H_data &= 0xf0;
    L_data = CMD;
    L_data &= 0x0f;
    L_data <<= 4;
    writeByte(0xfa);
    writeByte(H_data);
    writeByte(L_data);
}

void writeByte(int dat){
    digitalWrite(latchPin, HIGH);
    delayMicroseconds(80);
    SPI.transfer(dat);
    digitalWrite(latchPin, LOW);
}

void clear(){
    writeCommand(0x30);
    writeCommand(0x01);
}


int main (){
    setup();
    while(1){
        loop();
    }
    return (0);
}

Este programa mostrará los mensajes “Cooking Hacks” y “SPI LCD para Raspberry Pi” con un retraso de 2 segundos en el medio.

 Mas ayuda

Se puede obtener ayuda en la sección específica creada en este  foro.

Fuente cooking-hacks

CNC basado en Raspberry Pi


Si está buscando un proyecto que utilice Raspberry P , podría estar interesado en este impresionante grabador CNC Laser controlado por una Raspberry Pi y por algunos elementos reciclados de dos viejas grabadoras de DVD  y construido por Xiang Zhai.

El grabador láser Raspberry Pi ha sido construido en efecto utilizando dos unidades de DVD rescatadas de viejos ordenadores de sobremesa  y con menos de $ 10 en partes adicionales compradas en eBay, todo ello controlado por la Raspberry Pi. Si le interesa el concepto no lo dude pues la idea es bastante extensible a otros campos porque abre la via  para utilizar el sistema para otros usos.

 

En la mayoría de los proyectos de este tipo  los  grabadores láser se fabrican utilizando placas Arduino   programando  directamente la placa Arduino,pero es esta nueva versión construida por  Xiang Zhai ,   con una  Raspberry Pi es capaz de proporcionar más potencia. Su creador explica que la razón por la que elijio una  Raspberry Pi es porque es un dispositivo mucho más potente que Arduino , compatible con un sistema operativo completo y los pines GPIO pueden ser controlados por python (un lenguaje más intuitivo y más sencillo que C aunque la desventaja de python sea la velocidad lenta).Ademas  no hay  que comprar un controlador independiente para este proyecto   pues se puede controlar todo con un único Raspberry Pi pues este puede hacer muchas cosas diferentes sin recargar el firmware.

Además, hay personas de proyectos que ejecutan LinuxCNC en Raspberry Pi y utilizan una placa PIC 32 externa para controlar CNC. Es una gran idea, pero el autor aun queria o minimizar el costo. En su lugar, escribío  su propio intérprete python para ejecutar código G directamente. El grabador láser 2D CNC, es realmente muy fácil de controlar y no requiere demasiadas técnicas de programa.”

 

 

IMPORTANTE

Es muy importante tener en cuenta que el láser utilizado en este proyecto podría quemar la retina del ojo humano en menos de  un milisegundo antes de que el globo ocular sea capaz de reaccionar. Incluso un haz de reflexión aleatorio durante el grabado podría ser> 50 mW (para la comparación, un puntero láser regular es de 1 mW), y hacer daño permanente a los ojos, los ojos de los niños, o los ojos de los animales domésticos.  Debe s iempre usar gafas de seguridad Láser  cuando esté cerca del grabador de trabajo. Una adecuada para láser de 650 nm debe ser de color verde.

Instrucciones paso a paso

Componentes necesarios:

  1. Una Raspeberrry  pi (corriendo Raspbian o algun otro SO  que  soporte GPIO)
  2.  Dos unidades  regrabadoras de DVD recicladas.
  3. Para poder grabar, usted necesita el diodo del laser 200mW de un grabador  de DVD. Un diodo reciclado de un lector de DVD R o CD R no hará nada. Un diodo procedente de  un grabador de CD puede estar bien en términos de potencia (~ 100mW), pero el diodo láser de un grabador de CD es de infrarrojos, lo cual  puede ser muy peligroso pues no se puede ver.
  4.   Una caja de láser TO-18 5.6mm (Como este http://www.ebay.com/itm/251316903193?ssPageName=STRK:MEWNX:IT&_trksid=p3984.m1439.l2649)Asegúrese de obtener un 5.6mm uno. Hay otro tipo 9mm.
  5.   Dos puentes H de doble canal. El puente AH es un circuito que contiene cuatro interruptores (efectivos) que pueden aplicar una tensión a través de una carga (motor de corriente continua o una bobina de un motor paso a paso) en cualquier dirección.
  6. Dos motores paso a paso  reciclados de los DVD  pues son motores paso a paso bipolares bifásicos de 4 hilos. Requieren voltaje verdaderamente reversible en cada pares del alambre. Se necesitan dos puentes H para cada motor paso a paso. Así que el total de cuatro puentes H para dos motores strepper. Algunos controladores de motor paso a paso famosos como ULN2003 son para los motores paso a paso de 5 alambres, por lo que no se pueden utilizar para controlar los motores paso a paso de DVD. Puede crear sus propios puentes H usando 4 transistores NPN y 4 PNP y probablemente convertidores TTL (el pin GPIO de RPi es 3.3V para que se requieran chips TTL lógicos). O simplemente puede comprarlos. Hay una gran cantidad de circuitos H puente integrados disponibles en el mercado, como L298. Los utilizados  son L9110s Dual H Bridge comprado en Ebay. Son de bajo costo (~ $ 2 cada uno), compactos (.8 “x1”) y son suficientemente potentes (~ 800mA).  L9110s también se conoce a veces como HG7881.En cuanto al puente H, es necesario asegurarse de que el límite de corriente continua del circuito es superior a 500mA. Por lo general, el motor paso a paso en una unidad de DVD está clasificado en 5V y cada bobina tiene una resistencia de 10ohm. Así que la corriente a través de cada bobina sería 500mA! Una corriente muy grande!
  7. Un regulador LM317, un transistor bipolar de NPN de energía (como E3055, debería ser capaz de manejar continuo 200mA al menos), algunas resistencias, condensadores y un paquete de puentes. El LM317 es para el controlador láser. La energía NPN es para hacer un interruptor para el láser. Si no desea soldar un conductor por su cuenta, seguramente puede comprar un controlador de láser para <$ 5. El controlador láser debe ser capaz de salida de al menos 200mA a 2V y tienen la función de habilitar / deshabilitar. De hecho, será una mejor idea reemplazar el NPN bipolar con un transistor MOSFET. Hay muchos de ellos disponibles en el mercado y son muy baratos. Sólo asegúrese de que la corriente continua soportada por el MOSFET está por encima de 200mA.
  8.   Un soldador, destornillador y algunos accesorios de ferretería .

PASO 1 : Desensamble las unidades de DVD (escritores)

Hay un montón de video tutoriales  para este paso, así que lo veremos rápidamente en imágenes

Se parte de dos DVD reciclados


Es importante que al menos una unidad o sea regrabable

Todo lo que necesita del DVD son dos cosas:
  • El  motor paso a paso con la corredera (parte inferior derecha en la imagen de abajo)

Desmontando  un DVD
  • Los diodos láser (ver imagen abajo). Tenga mucho cuidado pues  los diodos láser en el DVD son muy frágiles. Asegúrese de no romperlos.

Dos diodos láser de 5.6mm (infrarrojos y 650nm rojo) comparado con un conector USB.

Motor paso a paso (derecha) y deslizante lineal. Soldar cuatro cables en el motor paso a paso.

Nota :Hay otras cosas buenas que puede salvar de la unidad de DVD y mantener para proyectos futuros, como un motor de 9 V cc cerca de la puerta, un motor sin escobillas que gira los DVD, algunos reductores de choque y algunas piezas de lente y óptica en miniatura. También puede encontrar cuatro imanes fuertes cerca del diodo láser. No los tire. Resultarán útiles más tarde.

PASO 2: Ensamblaje de los diodos láser

Ahora tiene dos diodos láser. Uno es el infrarrojo que no necesitamos. El otro es el diodo rojo 650nm (por lo general tiene una letra “R” en él) y es el que necesitamos. El diodo normalmente tiene tres pines que forman un triángulo (uno de los pines   es NC). Usted necesita un multímetro para averiguar qué dos clavijas son cátodo y ánodo. El voltaje delantero a través del ánodo y del cátodo debe ser alrededor 1.4V y la resistencia delantera debe ser 20-40k ohmios. Si la resistencia delantera es demasiado alta, entonces el diodo láser es usado excesivamente.

La carcasa del diodo láser

Diodo láser (centro izquierdo) y alojamiento láser
 
Empujar el diodo en la cabeza de la carcasa
Diodo láser en la cabeza de la carcasa
Soldar dos cables en el diodo
Utilice un poco de contracción de calor para aumentar la fuerza
Debe llegar hasta aqui:

¡Hecho!Ponga cuidadosamente el diodo láser en la cabeza de la carcasa del láser. Puede utilizar el cuerpo de la carcasa del láser para ayudar a golpear contra el diodo y empujar el diodo en la cabeza de la carcasa. El diodo debe encajar perfectamente en la cabeza. Asegúrese de que los pines estén bien. Entonces suelde dos cables a los terminales  y ensamble la cubierta al conjunto.

 

PASO 3 : Unidad láser LM317

Un diodo láser es como un fotodiodo pero equipado con una cavidad resonante. El diodo láser es un enorme sumidero de corriente. Una vez que el diodo conduce, genera mucho calor, y el calor disminuye más lejos la impedancia del diodo. Por lo tanto, es un sistema de retroalimentación positiva inestable. Si simplemente pone una batería de 1,5 V a través del diodo,  quemará el diodo o agotara la batería de inmediato. Necesitamos un controlador láser que pueda emitir una corriente constante al diodo.

Hay muchas formas de hacerlo,pero u na de las formas más populares y menos frustrantes es utilizar un regulador de corriente continua como por ejemplo usando   un  LM317   Mediante la adición de una resistencia través del pasador de ajuste y del pasador de salida, el LM317 puede generar una corriente constante de ~ 1,25 V / R.

[De hecho, LM317 se utiliza principalmente como un regulador de voltaje. Mantiene un 1.25V a través del perno de la salida (perno 2) y del perno del adj (perno 1). Mientras tanto, controla la salida de corriente desde el pin adj que es muy baja (usualmente <100 uA). Por lo tanto, añadiendo una resistencia R a través del pasador 2 y 3, podemos tener salida de corriente de 1,25V / R desde el pasador 2 al pasador 1. A continuación, agregamos el diodo láser a través del pasador 1 y GND. Dado que el pin 1 está prohibido hundir corriente, toda la corriente de 1,25V / R emitida por el pin 2 fluirá a través de R y diodo láser a GND. La hoja de datos oficial de LM317 se puede descargar aquí.

Aquí hay un buen circuito LM317 láser circuito que encontrado en  LM317 Laser Driver :
En esta  implementacion se sustituyen las dos resistencias paralelas de 10 ohmios por dos resistencias de  0.5 vatios de 12 ohmios pues l a corriente máxima que va  a pasar a través del diodo es 200mA.
Asegúrese de no estropear el pasador de ajuste y el pasador de salida.  Se necesita por razones obvias u n disipador de calor para el l LM317.

También necesita un conmutador que pueda ser controlado por RPi  por ejemplo  usando  un transistor de la energía NPN E3055. Usted puede elegir lo que cada uno quiere, sólo asegúrese de que el transistor puede soportar corriente continua CE> 300mA    ( también tendra qeu poner un disipador de calor en él).

Esquemas del controlador láser y el interruptor.El láser está encendido sólo cuando el puerto “Switch láser” es lógico alto (> 3V).Asegúrese de no estropear la orden de pin de LM317

LM317 driver láser

 

Controlador láser (superior) y la alimentación E3055 NPN (inferior)

NOTA: Los diodos láser son dispositivos muy delicados y s on extremadamente vulnerables a la condición aplicada en ellos. Una tensión o corriente inestable, una corriente / tensión excesiva (incluso durante un tiempo muy corto) podrían dañarlos permanentemente. Así que siempre descargue usted mismo antes de tener el diodo, y siempre use un controlador de corriente constante para alimentarlo .  T ambién podría dañar el diodo conectando primero el controlador a la fuente de alimentación y luego conectar el diodo al controlador. El diodo siempre debe estar conectado al controlador antes de aplicarle cualquier energía.  

 

 

PASO 4 : Ensamblar la máquina

¡Ahora usted tiene dos etapas lineales idénticas y es hora de juntarlas! Hay muchas maneras de hacer esto. Para máquinas CNC de 2 ejes, la mejor manera es la que da Groover @ instructable . En la configuración de Groover, la muestra de grabado se une al eje x, de modo que sólo se mueve en la dirección x. El láser está unido al eje y por lo que sólo se mueve en la dirección y. Esta configuración minimiza el peso en cada uno de los ejes.

Corte una placa de acero de 2 “x2” fuera de la caja de DVD y peguélo a la etapa de eje x como la base de soporte de muestra. Puesto que la caja del DVD se hace del hierro, usted puede utilizar los imanes fuertes rescatados del sistema óptico del laser para ayudarle a estabilizar la muestra del grabado en la base.
El diodo láser generará mucho calor. Y es importante disipar este calor. De lo contrario, el diodo se rom,pera  rápidamente. Corté un disipador de calor de 1 pulgada de cubo de un viejo disipador de calor de la CPU deun pc y  perforé un agujero a pesar de ello. El agujero es perfectamente grande para sostener el láser. Pegue el disipador de calor en las etapas del eje y.
La cuestión más importante es el eje x, el eje y y el cuerpo del láser tienen que ser perpendiculares entre sí.

PASO 5: Conecte el puente H a los motores paso a paso

Cuatro clavijas de conexión en un motor paso a paso de 4 hilos y 2 fases.Por lo general se organizan en el siguiente orden: a1, a2, b1, b2.(A1 y a2 son los dos conductores de la bobina a; b1 y b2 son los dos conductores de la bobina b).El uso de un multímetro ayudará a verificar esto.El motor paso a paso en DVD es un motor bipolar bifásico de 4 hilos. Hay dos bobinas independientes dentro. Cada bobina tiene una resistencia de 10 ohmios. Por lo general, los motores paso a paso DVD se clasifican en 5V. ¡Por lo tanto la corriente nominal a través de cada bobina es 500mA! Las clavijas RPi GPIO sólo pueden emitir menos de 20mA para que RPi no pueda controlar un paso directamente. H se requieren puentes.

 

En los escritos de la mayoría de las personas, definen la bobina 1 y la bobina 2 y el nombre 1a, 1b como los dos conductores de la bobina 1, y 2a, 2b como los dos conductores de la bobina 2. No importa, siempre y cuando sepamos qué nosotros estamos haciendo. Al menos en este post se  mantiene la terminología coherente.

La hilera central del motor paso a paso bipolar se puede considerar como un imán de barra (en realidad es circular). Obviamente, a partir de la figura anterior, si conducimos sucesivamente la corriente en la bobina a1, b2, a2 ​​y b1, la hiladora girará en la secuencia deseada. Para hacer esto, podemos aplicar una secuencia de voltaje a a1, b2, a2, b1 como: 1) alto, bajo, bajo, bajo. Por lo tanto, sólo a1 y a2 están activados. Dado que a1 a2 tienen la misma polaridad (o opuesto dependiendo de cómo lo defina), el hilador apunta a a1
2) bajo, alto, bajo, bajo. Por lo tanto, sólo se activan b2 y b1. Spinner está apuntando a b2
3) bajo, bajo, alto, bajo. Por lo tanto, sólo a2 y a2 están activados. Spinner señala a2
4) bajo, bajo, bajo, alto. Spinner apunta a b1.
Vaya a 1).

Denotan alto como 1 y bajo como 0. La secuencia puede escribirse como 1000.0100.0010.0001

La ventaja de esta configuración es que es muy fácil de entender y por lo general el motor paso a paso se mueve con mucha precisión. Sin embargo, puesto que en cada paso sólo se activa un par de bobinas, el par aplicado sobre la hiladora no es muy grande.

Para lograr un par alto, una forma más popular es aplicar la siguiente secuencia: 1100,0110,0011,1001. Y el hilador estará apuntando a medio de a1 y b2, medio de b2 y a2, medio de a2 y b1, medio de b1 y a1 consecuencialmente. Y el par se duplica. Esto se denomina modo de paso completo o modo de par alto o modo de dos fases .. y suele ser el modo utilizado.

Si el par de torsión no será un problema, entonces podemos usar una secuencia de 8 pasos: 1000, 1100, 100, 100, 0010, 0011, 001, 01001. La hilera girará 8 pasos en lugar de 4 pasos para girar el mismo ángulo. Esto duplica la resolución. Y el costo es el par no uniforme aplicado al motor paso a paso. Esto se denomina modo de medio paso.

Por lo general, para DVDs, los deslizadores lineales se mueven alrededor de 0,15 mm cada paso completo del motor paso a paso, lo que corresponde a una resolución de ~ 170dpi. Lo suficientemente bueno para los proyectos caseros. Si se implementa el modo de 8 pasos, entonces la resolución es 0.075mm / paso o 340dp, similar a la impresora normal.

Para el grabador láser, no hay ninguna carga grave en el motor de pasos, así que se elije el modo de medio paso o el modo de 8 pasos.

Como se mencionó, RPi no puede conducir el motor paso a paso directamente debido al límite de corriente. En realidad, además de alimentar los LED de baja potencia, los pines GPIO de un RPi suelen funcionar como conmutadores lógicos. En el modo de salida, son lógico Alto (3V) o bajo lógica (<0.7V). AH bridges es un “traductor” que traduce estas lógicas High o Low en fuentes de energía que tienen alta tensión o baja tensión.

Un esquema conceptual del puente H (de wiki)Arriba se muestra un  a esquema  conceptual del puente H (tiene una forma similar con la letra “H”). Un puente H tiene dos modos de funcionamiento: (S1 S4 cerrar, S2 S3 abierto) y (S2 S3 abierto, S1 S4 cerrar). En el primer modo, la corriente fluye hacia la derecha a través del motor y en el segundo modo, la corriente fluye hacia la izquierda a través del motor. En realidad, este puente H nunca se utiliza. Una manera común es usar el transistor como interruptores eléctricos. Vea la figura abajo.

Arriba vemos un esquema conceptual muy simplificado de NPN  .NUNCA construya un puente H basado en este gráfico .Probablemente quemará los transistores o incluso el Pi.Un puente H práctico requiere resistencias limitadoras de corriente, diodos inversos y chips TTL lógicos.Por favor, consulte más de otras fuentes si desea construir un puente H de trabajo desde cero.

Cuando A es lógico bajo (0V) y B es alto lógico (+ V), entonces el transistor 1 y 4 son conductores mientras que 2 y 3 están abiertos; Cuando A es lógico alto (+ V) y B es lógico bajo (0V), entonces el transistor 1 y 4 son oepn mientras que 2 y 3 son conductores. Cuando tanto A como B son lógicos altos, 2 y 4 son conductores, 1 y 3 están abiertos, el motor se detiene; Cuando tanto A como B son bajos, 1 y 3 son conductores, 2 y 4 están abiertos, el motor se detiene.

Por lo tanto, ajustando A y B alto o bajo, podemos controlar la dirección actual a través de una carga. Para cada motor paso a paso de dos hilos de 2 fases, hay dos bobinas independientes que necesitamos controlar. Así que un total de 4 puentes H se requieren para controlar los dos motores paso a paso.

Hay un montón de H integrado puente disponible en el mercado. Para mi caso, necesito 500mA a través de cada puente de H así que L9110S es suficiente (L9110S puede permitirse 800mA a través de cada puente de H). Cada L9110S contiene dos H puente para que dos de ellos es suficiente. Hay módulo L9110S para <$ 2 cada uno en el mercado. ¡Muy conveniente!  En el mercado puede vernir marcado como  L9110 o  L9110S ..

Además, L9110S tiene diodos internos de sujeción para conducir la corriente inversa generada por la parada repentina de los motores paso a paso. Esto protege el circuito. L9110S es compatible con el nivel de salida TTL / CMOS para que pueda conectarse directamente a RPi.

Dos puentes L9110 duales H (tambiénconocidoscomoHG7881).Son 0.8 “por 1” grande
Cada puente doble controla un motor paso a paso.A la derecha, hay a1, a2, b1, b2 conectores a los motores paso a paso (de arriba a abajo).En el lado izquierdo, hay pines de control lógicos para a1, a2, b1, b2 (en realidad se denominan A-IA, A-IB, B-IA, B-IB) y VCC y GND.

PASO 6: Controlar la máquina usando Raspberry Pi

Ahora esta es la parte clave. Debido a que no se esta utilizando controladores externos de motor paso a paso por lo que tenemoso que incorporar la función de los controladores externos paso a paso en el software ( se usa python para hacer el trabajo).

La gente dice que RPi no es un dispositivo de tiempo real porque tiene un sistema operativo completo en él y python es muy lento. Sin embargo, en mi caso, estos problemas no causaron ningún problema.

El código de python que escribío el autor  incluye las siguientes funciones:
1. Una clase de motor paso a paso bipolar encapsulado . Incluía información como fase y posición. Tiene una función de compilación .move (dirección, pasos) que convierte comandos de movimiento en una secuencia de comandos GPIO.output () que hace girar los motores paso a paso.
2. Intérprete de códigos AG: lea el código G y envíe los comandos correspondientes a los objetos bipolares de motor paso a paso. Para los comandos G02 y G03 (interpolación circular), el intérprete realiza la interpolación y convierte los comandos en una secuencia de movimientos rectos.

La parte más difícil es cómo controlar más de un motor paso a paso simultáneamente. La idea es realmente muy simple y se puede extender a cualquier número de motores. Ya sabemos cómo controlar un motor. Ahora supongamos que tenemos dos motores: MX y MY, y queremos convertir MX 12 pasos y MY 15 pasos simultáneamente en 6 segundos. Primero encuentre el multiplicador menos común (LCM) de 12 y 15, que es 60. Ahora divida 6 segundos por 60 obtenemos dt = 0.1sec. Establecer 60 bucles. Antes del final de cada ciclo, utilizamos los comandos time.sleep (0.1). Así que se tarda 6 segundos para terminar el bucle. Y nos movemos MX un paso cada 5 lazos y mover mi un paso cada 4 bucles. Después de 60 lazos, MX se mueve 60/5 = 12 pasos y MY se mueve 60/4 = 15 pasos. Y tanto MX como MY se movían a velocidades constantes.

00001 00001 00001 00001 00001 00001 00001 00001 00001 00001 00001 00001 (60 dígitos, 12 unidades)
0001 0001 00 01 0001 0001 0001 0001 00 01 0001 0001 0001 0001 00 01 0001 0001 (60 cifras, 15 cifras)

Para más de dos motores paso a paso, solo busque el LCM de todos los pasos (ignore 0).

Usted puede descargar todo el código de python aquí Mi RPi CNC Laser Engraver Código :

Puedes encontrar tres códigos de python:

Proyecto: raspberrypi-cnc-laser-engraver

El proyecto en Python lo componen 6 modulos:

  • Bipolar_Stepper_Motor_Class.py define la clase Bipolar_Stepper_Motor. Por defecto, la línea 5 es comentada y la línea 7 es válida. Esto corresponde a una secuencia de medio ángulo de 8 pasos. Si el par máximo es deseado, puede comentar la línea 7 y descomentar la línea 5 para seleccionar la secuencia de 4 pasos en ángulo completo.
  • Motor_control.py define un conjunto de funciones como LCM (para calcular el lcm de dos enteros) y Motor_Step (para controlar dos motores simultáneamente). Por lo general, no es necesario modificar nada.
  • Gcode_executer.py.  Este es el programa principal. Es necesario modificar la línea 25 (nombre del archivo de código G), la línea 29 (números de pasador del motor paso a paso X), la línea 31 (números de pasador del motor paso a paso Y), la línea 32 (número de pasador del interruptor láser), la línea 35, Resolución de la máquina en unidad de mm / paso) y línea 38 (velocidad de grabado). El código lee e interpreta el código G, y envía comandos correspondientes a las funciones de control del motor.
  • Spiral.nc : Este es un simple código G que traza una pequeña espiral. Puede probar perfectamente si la máquina puede procesar el código G, especialmente la interpolación circular G02 y G03, correctamente.
  • Grid.nc: Un simple código G que traza varias líneas rectas para formar una cuadrícula. Código perfecto para probar la máquina y hacer un sistema de coordenadas!

Actualmente Gcdoe_executer.py sólo acepta un número limitado de comandos G: G90, G20, G21, M05, M03, M02, G01, G02, G03.
El código puede reconocer comandos G1F (velocidad de grabado), pero simplemente ignorarlo. La velocidad de grabado se ajusta por la línea 38 en la unidad de mm / seg.

Como se mencionó al principio de este post, D. Miller hizo algunas mejoras a mi código para que el código pueda trabajar junto con la extensión inkscape GCodeTools y permitir el grabado remoto a través de otro pequeño script de python que escribió.

 

La versión modificada se puede descargar desde https://github.com/iandouglas96/engravR

PASO 7: ¡Grabado!

Después de Groover ( por Groover en instructable ), se usa Inkscape para hacer código G. Inkscape es un editor de gráficos vectoriales de código abierto y soporta varios sistemas operativos (windows, linux, Mac), lo que significa que deberías poder instalarlo en Raspbian! No se intenté. Simplemente puede usarsu pc y envíar su  diseño al RPi.

Necesita una extensión de grabado láser para convertir el gráfico vectorial en códigos G. Hay varios diferentes código de extensión G. El que yo uso puede descargarse aquí Inkscape-Laser-Engraver-Extension

[Nota: Ell autor escribío su intérprete de código G de python basado en el código G generado por esta extensión de Inkscape. Así que el código sólo puede tratar con un número limitado de comandos G, suficiente para el grabado con láser, aunque, afortunadamente. Para los códigos G dados por otro generador, mis códigos podrían no ser capaces de manejar todos los comandos. Es posible que deba modificar el código python por su cuenta.]

Aquí está la instrucción paso a paso sobre cómo generar código G que el código python puede procesarlo.

Paso 7-1: Instalar Inkscape y Inkscape-Laser-Engraver-Extension

Inkscape se puede descargar gratis aquí http://inkscape.org/en/
Se ejecuta en Windows, mac y varios sistemas operativos Linux.  Luego descargue Inkscape-Laser-Engraver-Extension

Para instalar la extensión, simplemente descomprima el archivo y copie todo en la carpeta de instalación de Inkscape. Por ejemplo, en Windows 7, si Inkscape está instalado bajo
C: \ Archivos de programa \ Inkscape
, Luego simplemente copie todo desde Inkscape-Laser-Engraver-Extension a C: \ Archivos de programa \ Inkscape \ share \ extensions
Y luego reinicie Inkscape, la extensión ya debe estar instalada. Para verificar esto, ejecute Inkscape y busque el elemento “Grabador láser” en “Extensión” en la barra de manu.

La extensión Laserengraver se ha instalado correctamente

Nota: Algunas personas informan que la extensión Laserengraver no funciona en Inkscape de la última versión. Si eso te sucede, utiliza Inkscape 0.48. El instalador de Windows se puede encontrar en la parte inferior de esta página.

Paso 7-2: cambiar el tamaño de la página

Abra Inkscape, vaya a “Archivo” => “Propiedades del documento” => “Página”, bajo el cuadro “Tamaño personalizado”, cambie las “Unidades” a “mm” (milímetro) y luego ponga 36 y 36 en ambos “Ancho “Y” Altura “. A continuación, cierre el cuadro de diálogo.

Verá que la página en blanco se convierte en un pequeño cuadro cuadrado. Zoom en esa caja.

Paso 7-3: trama, texto, crear, un montón de diversión ~

Puede escribir textos, graficar gráficos o incluso pegar png / bmp en el cuadro.

Pulse “Ctrl” y “A” para seleccionar todo lo que se traza, bajo “Path”, haga clic en “Object to Path”. O simplemente presione “Mayús” + “Ctrl” + “C”. Estos pasos son necesarios si tiene texto u otros objetos externos.

Convertir objetos en ruta

Paso 7-4: Generar código G

Va a “Extensiones” => “Laserengraver” y haga clic en “Laser …”. Un cuadro de diálogo saltará. Puede seleccionar “Directorio”, “Unir” y modificar otra preferencia en “Preferencia”. En “Laser”, escriba el nombre del archivo (debe adjuntarse a la extensión .nc). A continuación, haga clic en “Aplicar”.

Convertir el objeto en código G

Un cuadro de diálogo dirá “láser de trabajo, por favor espere ..”.

Si se selecciona “Dibujar gráficos adicionales para depurar la ruta de grabado” en “Preferencias” antes de hacer clic en “Aplicar”, Inkscape dibujará muchas flechas en la parte superior del gráfico, mostrando los movimientos dados por el código G generado.

¡El código G se ha generado correctamente!Muchas flechas.

Paso 7-5: Pase el código G a RPi

Si utiliza un ordenador portátil / escritorio para generar el código G, entonces tiene que pasar el código G a RPi usando ssh u otras herramientas. El código G debe colocarse en la misma carpeta junto con las rutinas de python.

Paso 7-6: ¡Haga la modificación necesaria en el código python y grabe!

Por lo menos desea cambiar el nombre del archivo de código G en Gcode_executer.py (línea 25). Algunos otros cambios, digamos, números de pin (línea 29, 31, 32), resolución (línea 35, 36), velocidad de grabado (38), se pueden cambiar si usted los entiende.

Escriba “sudo python Gcode_executer.py” en el terminal para ejecutar las rutinas de python y diviértete!

 

NOTAS

  • Acerca de la capacidad del grabador: Debido al límite de tamaño de las unidades de DVD, la máquina sólo puede grabar en un área de 36 mm por 36 mm .. Por lo que puede hacer pequeñas piezas de madera, cartón de plástico o parte de los casos de iPhone, pero no más grande.
  • El láser utilizado aquí es de 200 mW 650 mm de diodo láser rojo. Corta papel de carta bien. Pero no es lo suficientemente poderoso como para cortar cualquier cosa más gruesa y dura. De hecho, se prefiere que la superficie de trabajo sea de color negro para que pueda absorber la mayor cantidad de potencia láser posible. Para grabar en tablero de plástico transparente, como se muestra arriba en el icono de la moneda icono de la universidad icono, tengo que utilizar un marcador negro para pintar la superficie y limpiar la tinta después del grabado. Sin embargo, creo que para una hoja de espuma negra delgada (<3 mm de espesor), y dado suficiente tiempo de grabado, el láser debe ser capaz de cortar a través, como Groover mostró en instructable.

 

 

 

 

Ha habido muchos ejemplos de personas que usan Arduino para controlar CNCs. Probablemente puede encontrar toneladas de programas en C disponibles que se ejecutan directamente en Arduino para procesar el código G (una famosa es grbl). También hay controladores CNC disponible como MATH3 en el mercado que pueden ser controlado por puertos paralelos o en serie….pero este proyecto llega a un paso mas de simplificación usando solo una placa para todo

Para obtener más información sobre el nuevo grabador láser Raspberry Pi puedes visitar la página web Funofidy para más detalles. .

 

 

Comunicacion con un smartphone usando el magnetometro


Una forma barata y sencilla de comunicación entre un microcontrolador (por ejemplo, Arduinoo Netduino +) y un dispositivo Android es sorprendentemente difícil de lograr siendo el medio más práctico para lograrlo es utilizar un módulo Bluetooth o WiFi que aumente significativamente el costo de un proyecto (del orden de $ 30 – $ 60).

En este post veremos  un pequeño hack que permite comunicaciones de ancho de banda muy bajo en una dirección y prácticamente  sin costo alguno. No es práctico para la mayoría de las aplicaciones, pero  la idea era suficientemente interesante para explorarla 

Se puede utiliza el magnetómetro  de cualquier dispositivo para realizar una comunicación inalámbrica. El truco reside en crear una pequeña bobina a modo de antena y variar el campo magnético de la brújula del teléfono: de esta forma mediante esas pequeñas variaciones, podemos enviar datos al teléfono de una forma muy sencilla (la conexión de datos no es rápida ya que tan sólo permite un refresco de unos 40Hz pero es interesante ver cómo funciona).

Paraa probar el montaje necesitará lo siguiente:

  • Un teléfono o dispositivo Android que cuente con un magnetómetro (brújula electrónica). A dia de hoy no se conoce e ningún dispositivo sin uno.
  • Un Arduino
  • Aproximadamente 1 metro de alambre de cobre esmaltado (alambre del imán), aunque cualquier alambre aislado fino hará.
  • La aplicacion android ‘ Tricorder ‘ (disponible gratuitamente en la tienda de aplicaciones de Android)
  • Resistencia de 120 ohmios
  • Un diodo (opcional)

Haga una bobina envolviendo el 1 metro de hilo magnético alrededor de algo cilíndrico (por ejemplo, una pila  AAA) con un diámetro de aproximadamente 1 cm. Usted debe obtener alrededor de 30 vueltas de 1 metro. El diámetro o el número de vueltas no es importante mientras estén en bien erolladas para lo cual puede envolver  un hilo ligero alrededor de la bobina para ayudar a mantener su forma.

 

Conecte ahora a bobina como se ilustra en el esquema anterior. La resistencia de 120 ohmios limita el consumo de corriente a aproximadamente 40mA, que es el máximo permitido

El propósito del diodo es proteger el Arduino de un golpe de disparo de EMF cuando el pasador 13 está bajo. Esto se conoce como un diodo de retorno . Con sólo 30 vueltas y un núcleo de aire, es probable que salga sin usarlo,pero es una buena práctica incluirlo.

Ahora toca localizar el magnetómetro delterminal pues su ubicación variará de un dispositivo a otro. Aquí es donde el tricorder sera muy útil pues  la aplicación Tricorder  mostrara el campo magnético.

Para el HTC Desire la señal es más fuerte en la parte inferior . A la izquierda de la pantalla LCD es donde se encuentra el magnetómetro  pero esto es probable que varíe de un dispositivo a otro.

Ahora  cargue este skretch en su placa  Arduino antes de conectar la bobina.

  Unesdoc.unesco.org unesdoc.unesco.org
  * Generar una onda cuadrada de 1 Hz en el pin 13
  * /
 Void setup () {
   PinMode (13, OUTPUT);
 }

 Void loop () {
     DigitalWrite (13,1);
     Retardo (500);
     DigitalWrite (13,0);
     Retardo (500);
 }

Cuando la bobina está desconectada, debería ver el LED del Arduino parpadeando.

Ahora conecte la bobina. El LED debe dejar de parpadear en este punto porque la bobina pone en cortocircuito el LED ,lo cual  es lo  esperado.

Inicie la aplicación Tricorder y cambie al modo MAG e inicie la exploración.

Escanee metódicamente la bobina a través de la superficie del teléfono Android hasta que empiece a ver una fuerte onda cuadrada:donde vea la amplitud de este pico de señales es donde se encuentra el magnetómetro.

Debería ver una onda cuadrada similar si coloca la bobina en la misma ubicación en la superficie inferior del dispositivo. Utilice un poco de cinta para mantenerlo colocado allí.

Ahora tenemos una forma de detectar  en Android ,por lo que la tentación  es conectar la bobina al Arduino UART y comenzar a enviar  datos a 9600bps , pero desafortunadamente esto no va a suceder porque estamos limitados por la tasa de muestreo del magnetómetro disponible para nosotros por el sistema operativo Android.

Aquí está un histograma de time-between-samples de un HTC Desire ejecutando Froyo (Anrdoi 2.2) a una velocidad de muestreo máxima:

Podemos ver aquí que casi todas las muestras vienen en entre 18ms y 25ms. Hay algunos  picos qeu van todo el camino hasta 45ms pero  son tan pocos que podemos ignorarlos. Esto significa que estamos limitados a un máximo de una tasa de muestreo de 40 Hz. Si manejamos la bobina con una línea de E / S digital que inmediatamente tapa nuestro ancho de banda máximo a 40bps.

Este otro sketch para  Arduino energiza la bobina con una onda cuadrada de inicio a 500Hz y disminuye a aproximadamente 1Hz durante unos segundos.

  Int i;
 Int d = 1;
 Void setup () {
   PinMode (13, OUTPUT);
 }

 Void loop () {
   Para (i = 1; i <500; i + = d) {
    
     // Aumenta el incremento a medida que disminuye la frecuencia
     D = (i ^ {6}) + 1;
   
     DigitalWrite (13,1);
     Retraso (i);
     DigitalWrite (13,0);
     Retraso (i);
   }
 }


Aquí están los datos del magnetómetro:


Como se esperaba, no se detectan altas frecuencias (a la izquierda). Parece que sólo obtener buena recogida cuando la frecuencia baja a alrededor de 6Hz!

Para la codificación utilizamos NRZ (no retorno a cero) similar a la utilizada en RS232 con un período de bit de 140ms (aproximadamente 7 bps). El límite inferior UART de Arduino es de 300bps, así que no podemos usarlo para generar la señal.

Del mismo modo, en el terminal Android vamosa tener que decodificar en el software también.

#define BIT_DELAY 140

int i;
char *text = "Hello World! ";

void setup() {
  pinMode(13,OUTPUT);
}

void loop() {
 
  char *s;
  s = text;
  while (*s != 0) {
    transmitByte(*s++);
  }
  
  delay (BIT_DELAY*10); 
}
/**
 * Bit bang a byte
 */
void transmitByte (byte c) {
  
  // Start bit
  digitalWrite (13,1);
  delay(BIT_DELAY);
  
  // Data bits
  for (i = 0; i < 8; i++) {
      digitalWrite (13, ( (c&0x80)!=0 ? 1 : 0) );
      delay(BIT_DELAY);
      c <<= 1;
  }
  
  // Stop bit
  digitalWrite (13, 0);
  delay(BIT_DELAY);
}

 

Aquí vemos el ejemplo  en acción:

Nota :la aplicación Tricorder no esa disponible temporalmente en Google Play ,pero en su lugar hay algunas apps similares como  Magentic Filed measure

Via    jdesbonnet

Ambilight para nuestro PC


Ambilight es una tecnología diseñada para mejorar la experiencia visual  analizando las señales entrantes y produciendo una  luz lateral ambiental adecuada al contenido que se está visualizando en la pantalla un resultado bastante atractivo , el cual  además de la sensación de estar viendo una pantalla aun mayor.

Hasta hace muy poco este efecto solo se podía conseguir si comprábamos un TV que contara con ese sistema y no había otra opción, pero recientemente  con la aparición de placas con suficiente capacidad computacional, se puede emular gracias al uso por ejemplo de una Raspberry Pi .  Aun mas sencillo  y facil es hacerlo a través una placa Arduino UNO (o incluso Arduino nano), un ordenador,y una tira de 50 leds para iluminar una televisión de 47 pulgadas..!Y todo sin tener que soldar nada!.

 

 

Antes de empezar  con el montaje ,  la tira de  leds   RGB   direccionable es muy importante que este basada en el chip  ws2801 (LEDs WS2801) pues el menos no nos  dará  ningún tipo de problemas usando una Placa Arduino,  siendo ademas la mas utilizada para este tipo de montajes.

Existen tiras basadas en el chips WS2801   en formato “luces de navidad”,pero lo mas habitual es adquirirla en forma de cinta autoadhesiva.

Un ejemplo de tira es  esta  que puede comprarse en Amazon por menos de 27€

tira de leds.png

Una peculiaridad  de esta tiras ,es que se pueden cortar según la longitud que se requieran , así como además que también es posible ampliarlas gracias a  los conectores que llevan en cada extremo, pudiendo  unirse  entre ellas hasta donde se necesite.

conector.png

Asimismo, para alimentar dicha tira  también  necesitaremos aparte  una fuente de alimentación  dimensionada para el números de leds que vayamos a adquirir , como puede ser una fuente de  5v y 2A  (para 50 leds)

La tira de leds por simplicidad la conectaremos a una placa  Arduino UNO , el cual puede adquirirse en Amazon por menos de 10€

Arduino UNO comparado a la versión anterior, usa el  Chip alternativo Atmega 16U2 8U2, lo que quiere decir una tasa más alta de transferencia y memoria.Ademas esta versión cuenta con la interfaz SDA y SCL .

Los datos de LED y las líneas de reloj los conectaremos  a la salida SPI de Arduino,es decir  los datos SPI salen del pin digital 11 y  el reloj es el pin digital 13.

Los LED deben ser alimentados externamente fuera de la linea de +5V de  Arduino 5V, pues podrían estropear el regulador de este . La masa o  tierra, por el contrario, si debe ser conectada a  la masa de Arduino.

Normalmente las tiras de leds WS01  ,suelen tiene 6 cables : tres de ellos lo  conectaremos los pines (11,13 Y GND) del Arduino, y los otros dos  conectaremos  a la fuente de 5V.

La forma de conectarlos todo esto es según el siguiente esquema :

  • El cable VERDE proveniente del pin SD de la tira de leds al pin 11 del Arduino Uno.
  • El cable ROJO proveniente del pin CK  de al tira de leds al  pin 13 del Arduino Uno.
  • El cable NEGRO proveniente del pin  GND de la tira de leds al pin GND del Arduino Uno.
  • El cable AZUL proveniente del pin +5V de al tira de leds lo dejaremos sin conectar
  • El cable Rojo grueso en paralelo con el azul  proveniente de la tira de leds a la conexión +5v de la fuente auxiliar
  • El cable NEGRO en paralelo con el  negro  proveniente del pin  GND de la tira de leds al GND de la fuente auxiliar

arduino.png

Conectamos pues  la tira de leds  por un lado a una fuente de 5V /2amp .  y por el otro a Arduino , por uno de los extremos y las otras 2 o 3 tiras con los adaptadores macho hembra adecuados   a continuación siguiendo la flecha  de las tiras  haciendo un rectángulo que rodeara nuestro monitor o TV .  Evidentemente en uno de los extremos de inicio es donde haremos las conexiones  y todas la demás se harán por medio de los  conectares .

Hemos de tener cuidado ya que uno de los extremos de la tira de luces es pues para conectar la primea tira al arduino y a la fuente :de esta forma, en cada extremo quedan sueltos los cables opuestos (normalmente el cable rojo es el positivo y el azul el negativo.) que conectaremos también entre si para dar alimentación a  los leds ( aunque los conectores también den energía  ya que llevan las 4 conexiones incluida los 5v y GND)

 

 

 SOFTWARE EN EL ARDUINO

Para gobernar , la tira de leds la conectaremos a  un   Arduino   que  ademas  hará de “puente” entre el ordenador host y la tira basado en WS2801 . Los datos de LED se transmiten, y  no se almacenan en búfer, lo que significa que si  hay mas código en Arduino  podrían generar demoras debido a la RAM limitada del Arduino,pero no obstante el algoritmo ejerce cierto esfuerzo para evitar las pérdidas de buffer

 El protocolo de cierre WS2801, basado en retardo, podría desencadenarse inadvertidamente si el bus USB o la CPU  está desbordada con otras tareas. Este código almacena datos entrantes en serie e introduce pausas intencionadas si hay una amenaza del buffer  lleno prematuro.

El costo de esta complejidad es algo que  reduce el rendimiento, pero la ganancia es muy buena  evitando  la mayoría de los fallos visuales  incluso aunque finalmente una función de carga en el bus USB y  host CPU, quede  fuera de  control.

 

Si no lo tenemos, descargaremos el software de arduino (Página oficial de arduino) y lo instalamos.

Conectamos el arduino uno a nuestro pc con el cable usb. Si pide los drivers, se pueden encontrarlo en la carpeta arduino-1.0.4\drivers.

Descargaremos  esta biblioteca:fastled biblioteca descarga, la cual  importaremos  al Arduino IDE.

Ahora toca cargar el sketch para lo cual  descaremos el código Adalight para las luces  aqui 

Descomprimireos el archivo y  añadimos los archivos que acabamos de descargar en la carptea Mis documentos/ Arduino  y ng

Arrancaremos el software de arduino y  configuramos en el ide la placa Arduino en Herramientas –>Placa Arduino Uno ( o la placa que tengamos)   sin  olvidar el puerto de comunicaciones

Iremos a  File> Sketchbook> Arduino> Adalight  y uan vez cargado el sketch debemos ajustar el numero de leds  (88 en nuestro casoo) que  tengamos en la instalación  así como la velocidad máxima (500000 )

 #define NUM_LEDS 88 // Max LED count
#define LED_PIN 11 // arduino output pin – probably not required for WS2801
#define GROUND_PIN 10 // probably not required for WS2801
#define BRIGHTNESS 255 // maximum brightness
#define SPEED 500000 // virtual serial port speed, must be the same in boblight_config

Ahora ya podemos   compilar el software( botón primero que  pone un v de verificar).

 

adalight.PNG

 

Si no ha habido errores ahora podemos subir  el sw pulsando el botón de Upload( flechita a la derecha  en el software de Arduino.

Al contrario de lo que sucede  con el sketch LedlIght donde se iluminan las luces  de 3 colores rojo, verde y azul si todo ha ido bien, si tenemos conectadas los leds al arduino y a la fuente externa, cuando carguemos este  código dentro del Arduino solo lucirá el primer led de la cadena lo cual significará que estamos en buen camino.

IMG_20170221_170329.jpg

 

El código dentro de Arduino es no volátil, así que no se borrará aunque desconecte la tarjeta.

 

Sw en el PC

Una vez tenemos el sw de Adalight en un Arduino, toca instalar  el programa de captura que  envíe las señales correspondiente a nuestro Arduino

Entre los programas de captura  ambibox es el mejor especialmente con  windows 10, ya que no solo  tiene la capacidad para capturar su escritorio  sino de poner un fondo personalizable, convertir la tira en luces psicodelicas en función del audio,fondo variable automático ,plugins, etc

Se  puede encontrar aqui, tanto el software como el add-on para XBMC.

 

Una vez   descargado , durante la instalación se puede seleccionar  la opción de instalación completa ,marcando ademas la opción de descarga e instalación de playclaw.

Empezamos la configuración, pulsamos sobre el botón de mas ajustes :

more

En la parte inferior ,como vemos seleccionaremos como Device  Adalight , elegiremos  el puerto de comunicaciones ( el mismo al que este conectado el Arduino) y en el numero de zonas, coloremos  el numero de leds total que tengamos instalados ( en el ejemplo 88).

Asimismo no olvidar orden de colores,lo cual podemos obtener   fijando un color mediante el selector de Mode:Static Background   ,pinchando en el color ( aparecerá la paleta),pinchando en el check de Use baclight   y seleccionando en el combo order of colors la opción adecuada   hasta que el color de los leds sea similar al de paleta ( en mi caso es BGR)

 

fondo.PNG

IMG_20170221_204134.jpg

En este programa no olvidar  en salvar cada cambio en “Save Setting”  pues si no lo hacemos perderemos cualquier cambio que hagamos

Con las nuevas opciones ya podemos avanzar en la  configuración de nuestra instalación para lo cual seleccionaremos en Mode  :Screen capture

 

capturawindiow.PNG
Acto seguido configuramos la ubicación de los leds, pulsando  sobre SHOW AREAS OF CAPTURE y sobre el asistente de configuración,elegimos si queremos una instalación de 3 lados o 4. También  es importante la cantidad de leds que tenemos en cada lado de la TV especialmente horizontal o verticalmente.
Marcamos asimismo el orden de los leds, de izq->der o de der->izq.
Con esto ultimo ya tenemos nuestro software listo para funcionar

2017-02-21_20h59_23.png.
Este programa además tiene unas opciones muy interesantes, en esta pantalla:

adicional.png

Podemos configurar muchos parámetros de cada led, aplicar correcciones de color y gamma ,brillo ,etc

También podemos activar un servidor web para controlar el software desde el teléfono

servidor

 

El siguiente paso es instalar el add-on para el XBMC.Para ello Lo descompriremo y lo ponemos  en la ruta:”Users/Username/AppData/Roaming/XBMC/addons”

Ahora en el  apartado de add-on ( en el  menú de la izquierda ) se puede configurar un poco el comportamiento, aquí cada cual que lo puede personalizar a su gusto.

Una solución para que funcione a pantalla completa es usando el software playclaw.
Para ello, se pueden  es crear 2 perfiles dentro de ambibox, uno para el escritorio y otro para XBMC.
En este ultimo el sistema de captura que elijo es playclaw de modo que cuando se inicie un video en XBMC  dará la opción de elegir que perfil cargar, de modo que se  puede  elegir el perfil XBMC y asi  cuando se  salga de XBMC se  puede vplber   al perfil de escritorio.
Por supuesto se debe tener corriendo el software playclaw para que esto funcione.

 

Por ultimo  hay  un  modo  que haya las delicias de los que les guste la música  : el modo Color music , el cual permite modular las luces en función  de lo que se este escuchando por el canal de sonido principal.

 

musica.PNG

 

Obviamente si queremos que las luces acompañen a la imagen de video de la pantalla principal el modo de captura de pantalla elegido sera  [Software] Screen capture  y el Método  Windows 8  ( aunque tengamos Windows 10 instalado en nuestro equipo)

windows8.png

Para terminar dejamos dos test de vídeo , que a pantalla completa,  nos pueden servir para testear si nuestro sistema responde correctamente.

 

 

Cómo probar una tira de leds WS2801


Es muy frustrante adquirir  una costosa tira de leds  WS2801 ( ni importa que sea SMD o en formato “luces de navidad”) ,  adherirla y fijarla  con mucho esmero a nuestro TV o monitor ,siguiendo  cuidadosamente los muchísimos tutoriales que hay en Internet (por ejemplo para simular  con esta  el famoso  sistema ambilight ),   y al final no conseguimos obtener nada  quizás porque nuestro hardware esta mal conectado (o tenemos algo estropeado)  o bien no hemos  configurado el sw ,o una mezcla de ambas cosas.

Antes de abandonar veamos  con la ayuda de una placa Arduino Uno conectada a nuestro PC  , vamos  a ver algunas pautas que seguro  nos resuelven el misterio:

 

En primer lugar usaremos una  placa Arduino UNO , para lo cual usaremos sólo  tres cables para  conectar a uno de los  extremos de la tira de leds a Arduino . Las conexiones estandarizadas que haremos sea cual sea la modalidad de la tira de leds son las siguientes:

  • CK de la tira WS2801  al pin GPIO 13(reloj del SPI)
  • SD de la tira WS2801  al pin GPIO11 (SPI MOSI).
  • GND de la tira WS2801 al GND de Arduino
  • +5v   de la tira WS2801  a  una fuente de alimentación aparte de mínimo 2Amp ,5VDC

En algunas tiras formato “luces de navidad” el hilo azul es  GND , el . Verde  es CK  y amarillo es SD ,y el cable rojo es +5V ,  pero esto no es norma porque las tiras SMD   suelen tener un cable rojo para CK, otro verde para SD , el negro para GND  y un violeta para +5V  , lo cual como vemos no sigue para nada la pauta anterior

Aunque no es necesario  también se puede utilizar un Arduino Mega, conectando  reloj del SPI al pin 52   ,  conectando SD al   pin 51 SPI MOSI  y por supuesto las masas.

Es importante destacar que los cables extra rojo y azul son para conectar  5V DC   de al menos 2 Amp ( en función del numero de leds que vayamos a conectar)  lo cual no deberíamos extraer de la placa Arduino sino de una fuente auxiliar DC de 5V    no  olvidando de unir ambas masas ( la de Arduino y de la fuente externa).

En el siguiente esquema podemos ver claramente este montaje.
led_pixels_wiring-diagram.png

Para probar   la tira  de leds    necesitamos si aun no lo tenemos dos herramientas :

  • El IDE de Arduino :Si no lo tiene ya instalado , descargar el Arduino IDE (entorno de desarrollo integrado) de la Web de Arduino. Seleccione la versión del software para su tipo de computadora: Windows, Mac o Linux   Es un poco diferente para cada uno de los tres sistemas operativos.
  • El IDE de Processing:A continuación, descargue el IDE de processing del sitio de procesamiento.Descomprima el fichero y cópielo al  directorio  c:\archivos de programa\ . Es importante que descargue la versión processing 2.2 pues la  versión 3.0  con el codigo Adalight  tendra  errores con él.
El IDE de Arduino y Processing  son  muy similares pero son dos programa muy distintos para diferentes funciones como vamos a  ver

Descargar Adalight ZIP

Por último, visite la página Adalight en Github y descargue el archivo ZIP. El botón de descarga está cerca de la parte superior izquierda de la página:

Después de descomprimir el archivo ZIP, necesitará mover algunos archivos en su lugar.

Si ha ejecutado el Arduino o el IDE de processing  debería haber  dos  correspondientes carpetas llamadas “Arduino” y de “Procesing” dentro de su carpeta personal de “Documents” (o “Mis documentos” en Windows). En ese caso, mover el contenido de la Arduino y procesando carpetas desde el archivo ZIP de Adalight en las carpetas correspondientes de documentos.

Si las carpetas de Arduino y Processing todavía no existen en el sistema,  puede copiar estas desde el archivo ZIP de Adalight a la carpeta de documentos.

Los otros archivos y carpetas en el archivo ZIP pueden ser ignoradas ya  que son para usuarios avanzados y no son esenciales para su uso.

Salga del Arduino y Processing  si se están ejecutando  pues las carpetas recién instaladas no serán visibles hasta la siguiente vez que inicien  estos programas.

Programar Arduino

Para  probar la tira de leds  en caso de que no lo tenga instalado deberá instalar  el IDE de Arduino.Si no lo tiene instalado el IDE de Arduino conecte la placa Arduino al ordenador con un cable USB A-B. Cuando conecta por primera vez, Windows los usuarios le pedirá que para instalar a un controlador.

Iniciar el IDE de Arduino. Después de un momento, debería ver una ventana azul y blanca simple con algunos botones.

En el menú archivo , seleccione Sketchbook,   y elegir  LEDstream. .

En el menú herramientas , seleccione la  placa  luego Arduino Uno (o tipo de cualquier placa Arduino que está usando).

En el menú herramientas , seleccione el Puerto Serial y luego el puerto correspondiente a su placa de Arduino.

Haga clic en el botón de subir cerca de la parte superior izquierda de la ventana:

ledsstreamarduino

Después de que el código sea cargado, si los LEDs están conectados correctamente conectados y la fuente de alimentación está conectada, todos  los LEDs deben encenderse en una secuencia  primero todo todos en flash rojo, luego  verde y después en azul aproximadamente un segundo cada uno, y luego se apagan todos. Se trata de un diagnóstico que indica el LED Arduino están trabajando correctamente y ahora están en espera de datos de que se  envíen desde nuestro ordenador con otro sw.

Gracias    a que el Arduino almacena el programa en memoria no volátil, sólo necesita hacer este proceso de carga una vez, no cada vez que desee utilizar Adalight.

Si los LED no parpadean, asegúrese de que el cableado coincide con la página anterior, y que la fuente de alimentación está conectada.
Si persiste el error  deberíamos probar la salida digital de los  pines 11 y 13 por si estuviesen defectuosas, para lo cual conecte dos leds normales  entre GND  y los pines 11 y 13  y cargue en Arduino el siguiente código de ejemplo:
void setup(){
pinMode(13, OUTPUT);
pinMode(11, OUTPUT);//10 ok 11 ok
}void loop(){digitalWrite(13,HIGH);
digitalWrite(11,LOW);delay(1000);

digitalWrite(13,LOW);
digitalWrite(11,HIGH);

delay(1000);

Al subir el código anterior en nuestro Arduino ,  ya deberían parpadear ambos leds , lo cual sera un claro indicio que la placa Arduino esta bien:

led13

 

Una vez hayamos probado que la placa Arduino esta correcta  con el simple test anterior,  lo que nos queda es volver a cargar el sketch de  probar LedStream cargado inicialmente pues  hay evidencias  de que algún (o algunos) modulo(s)  mal que esta bloqueando el resto de módulos

En el caso de que sólo los primeros pocos LEDs respondan  y ,el resto permanece apagado o parpadea aleatoriamente o incluso no se encienda ninguno, tendrá que estudiar cual de  los módulos esta mal  .

Dentro de cada píxel  hay  una pequeña placa de circuito con el CI WS2801   el led RGB   y algunos componentes adicionales . Si no funciona  el primer píxel apretar las conexiones  donde el cable de cinta se une a la placa  e intente comprobar la conexión ,Si no  funcionase , puede recortar  ese modulo , conectando las conexiones al siguiente  píxel   y seguir la  dirección de conexión ( en el montaje SMD  llevan una flecha  que indica claramente el orden de conexiones)

ws2801

Si consigue que algunos  leds  funcionen pero aún así  algún  led posterior  parpadea ,y fallan después todos los siguientes en la cadena ,también  es muy  posible que ademas  haya algún  otro chip defectuoso  más ,  así que el proceso  anterior lo  deberá repetir  cortando el  led asignado a ese  IC defectuoso y restituyendo las conexiones soldando cablecillos entre el modulo anterior y el siguiente .

img_20170219_222107

Obviamente este proceso tendrá  que repetirlo  hasta que  el test de leds ejecutado desde el  sketch de ledstream haga que se enciendan completamente todos los ledss de un color en las tres secuencias.

Ejecutar el Software de Processing

Este paso debe realizarlo solo cuando el  test de ledStram muestre la secuencia de arranque de rojo, verde y azul apagándose todos después.

Inicie  el programa Processing ejecutando el archivo “C:\Program Files\processing-2.2.1-windows64\processing-2.2.1\processing.exe”. Después de un momento, debería ver una ventana simple de blanca y gris  muy similar al IDE de Arduino.

En el menú archivo , seleccione carpeta de bocetos,  y seleccionar el último primero: Colorswirl.

 

color
Es muy importante anotar el numero de leds( en el ejemplo 88)   tras el primer import:

import processing.serial.*;int N_LEDS = 88; // Max of 65536

Haga clic en el botón Ejecutar cerca de la parte superior izquierda de la ventana: si el Arduino esta arrancado con el sketch (LedStram ) y por supuesto conectada la tira de leds a este  y alimentada con la tensión de 5V  se  debería ver un arco iris colorido de animación sobre los LED.

Si  no pasa nada , entonces usted tendrá que editar el código alrededor de la línea 26, buscando esta declaración:

myPort = serie new (this, Serial.list() [0], 115200);

Necesitaremos cambiar el código  que abre la conexión serie con el Arduino. Una ruta es a través de ensayo y error: tratar  Serial.list() [1], entonces Serial.list() [2]y así sucesivamente, volver a arrancar el programa cada vez para ver si funciona.

Para un enfoque más científico, añadir una nueva línea de código antes de ejecutar el sketch:

println(Serial.list());

Cuando se ejecuta, muestra una lista de todos los puertos serie o dispositivos. Si sabe que dispositivo o puerto COM corresponde al Arduino, puede cambiar la línea original para incluir estos datos.

Por ejemplo, ahora se puede leer:

myPort = serie new (this, “COM6”, 115200);

Obviamente esto será diferente en cada sistema, por lo que dependerá de cada situación..

Si aun tiene dudas ,otra manera de localizar el nombre del puerto, es en el IDE de Arduino, pues  el puerto seleccionado se ve  en el menú Tools→Serial Port antes de programar el chip.

Una vez conseguido este efecto sobre los leds , este resultado es sinónimo que absolutamente todos los leds son direccionables por lo que ya puede usar su conjunto de tiras de leds  para cualquier aplicación con la certeza de que ya  le debería funcionar.
Si planea organizar los LEDs de manera similar a los ejemplos  entonces tendrá nada más que cambiar  el software. Si utiliza un diseño diferente, necesitará realizar algunos ajustes en el código  para identificar su distribución concreta

Como nota ultima :Antes de montar los LEDs detrás del monitor o TV , nunca se olvide de ejecutar el software con los LEDs sueltos en su escritorio para confirmar que todo funciona. !Esto ahorrará tiempo y angustia en el raro evento que un led vuelva a estar mal  tenga que sustituirlo!.

img_20170219_225945

 

Cómo crear y gestionar mas de una cuenta de g-mail


Gmail,  es un servicio de correo electrónico con posibilidades POP3 e IMAP, que es semi-gratuito(puesto que también tiene una versión empresarial de pago)  proporcionado como todos sabemos por Google. Este servicio aunque parezca que lleva toda la vida con nosotros en realidad  es  bastante “reciente  puesto que inicio su andadura  como beta a  partir del 15 de abril de 2004   hasta que en el 7 de julio de 2009, junto con Google Calendar, Google Docs, Hangouts   dejaron su calidad de Beta y pasaron a ser considerados productos terminados.

En noviembre de 2012, Gmail logró superar a Outlook (el servicio de correo electrónico más utilizado hasta esa fecha) en cuanto a número de usuarios registrados a nivel global sin duda propiciado por el  gran éxito del sistema operativo Android, llegando en mayo de 2014 a superar las mil millones de descargas en dispositivos Android.

Algunas de las innovaciones que incluía   g-mail desde las versiones previas:

  • Personalización de la bandeja de entrada :se puede vestir la bandeja de entrada al gusto habiendo miles de temas para elegir que además se pueden cambiarlo cuando se desee.
  • Centralización de Gmail  permitiendo utilizar una sola dirección de correo para todo: mensajes personales, compras, vida social, pagos, búsqueda de trabajo, etc.
  • Bloquea de spam
  • Ordenación de  los mensajes en su sitio  para no ver la bandeja de entrada colapsada.
  • Multidispositivo :se puede consultar el correo se esté donde se esté con las aplicaciones Gmail para Android, iPhone y iPad recibiendo  notificaciones en tiempo real para que no perder los correos importantes.
  • Posibilidad de chatear, llamar por teléfono y hacer videollamadas.
  • etc

 

Aunque no lo parezca ,  no hay ningún problema para tener varias cuentas de Gmail para uso  personal , tanto es así que en efecto se puede tener  todas la cuentas de g-mail  que se necesiten.

Si no sabe como hacerlo , a continuación describimos  los pasos :

En primer  haga  click en el siguiente link para poder crear otra cuenta: https://accounts.google.com/SignUp?service=mail&continue=http%3A%2F%2Fmail.google.com%2Fmail%2F

gmail.png

 

Como vemos la información obligatoria que se nos solicita  :

  • Nombre
  • Apellidos
  • Contraseña( solo admite letras o números)
  • Fecha de nacimiento
  • otra cuenta de correo( puede ser distinta de gmail)
  • Teléfono

 

Cumplimentados todos los pasos , tendrá que darle a botón del siguiente paso.

A continuación nos saldrán las condiciones de uso:

 

captura

Si estamos de acuerdo, pasaremos ACEPTO y  a continuación ya nos mostrara la bandeja clásica  de entrada , con únicamente el correo asociado a esa cuenta

 

Si tenemos mas de una cuenta de Gmail , para poder ver  todas las cuentas asociadas desde el mismo interfaz ,pinchamos el rueda dentada , opción “Configuración

Pulsaremos “Cuentas en importación”

 

confi

Ya solo nos queda pulsar en “Añadir otra dirección de correo”

Tras cumplimentar la dirección enviara un correo con un link para comprobar

otra-direccion

Ahora en la caja introduciremos  el código de conformación que recibiremos en la otra cuenta de gmail

verifica

Una vez que lo introduzcamos  ambas direcciones de correo de Gmail  se podrán consultar usando una única credencial  y por supuesto accediendo al correo de ambas cuentas

Puede que en principio no pueda parecernos tan interesantes pero seguro con el tiempo aprendemos a sacar rentabilidad a esta magnifica oportunidad que  nos ofrecen