Convierta en mini PC una Raspberry Pi


Hablamos de un curioso Kit   que   permite cambiar completamente la funcionalidad de una Raspbrry  pi 3 conviertiendo ésta  en un  funcional minipc con una estética muy lograda

El kit se conecta a una Raspberry Pi( que por   cierto no va incluida)   a través del   puerto GPIO de 40 pines del que hemos hablado en este blog  permitiendo que luego conectemos una unidad SSD a esa placa auxiliar gracias a la interfaz mSATA y a la presencia de un pequeño adaptador de corriente que suministra la energía necesaria para que tanto la Raspberry Pi como la unidad de almacenamiento funcionen sin problemas. Obviamente precisamente uno de los puntos interesantes de este kit es que gracias a  este puerto  la Raspberry Pi puede iniciarse desde el SSD, y no necesariamente desde una tarjeta microSD como es lo habitual . Incluso la placa HAT lleva un conector macho superior para encadenar con otra placa HAT adicional que necesitemos.

 

rp3

Además ofrece un reloj en tiempo real (RTC) para mantener el reloj en hora incluso sin alimentación (incluye batería CR2032),

 

pila.png

Otro detalle interesante que se hecha en falta en su versión  de caja tradicional  es contar   con  un botón  un control de alimentación inteligente  que permite encender y apagar la Raspberry Pi de forma segura  sin perder datos y sin necesidad de quitar el cable de alimentación.

caja.png

 

Respecto a  la elegante caja esta aprovecha los puertos de la Raspberry Pi 3, contando con refrigeración mediante un pequeño disipador, un adaptador USB y una pila para el reloj del sistema,botón de encendido  e incluso una abertura para puede instalar una Raspberry Pi Cam en la parte frontal de la caja.
El kit incluye:

  • HAT para instalar disco SDD mSATA
  • Disipador de calor para la Raspberry Pi 3
  • Adaptador USB externo (Micro-Type A)
  • Espaciadores largo (x4) ,  corto (x4) y tornillos para sujetar la Raspberry Pi (x4)
  • Elegante caja 18x18x4,5cm
  • Batería (CR2032)
  • No incluye la Raspberry Pi 3.

 

 

Respecto al al software  recomiendan  RaspAnd OS que también incorpora de inicio varias aplicaciones recientemente actualizadas entre las que podemos mencionar Spotify TV 1.2.0, Rotation Control Pro 1.1.2, Google Play Games 3.9.08, Clash of Clans 9.24.9, el gestor de correo Gmail 7.4.23 o Aptoide TV 3.2.1.

Además merece la pena saber que también se ha incluido el paquete GAPPS para que los usuarios que se decanten por esta interesante alternativa, a su vez también tengan acceso a los servicios de la firma Google. Llegados a este punto decir que GAPPS incluye Google Play Services, pero no la tienda oficial Google Play Store.

 

Como vemos pues con este kit  por  unos 65€   podremos  convertir  una  Raspberry Pi 3 en un ordenador con WiFi, Ethernet, Bluetooth, RTC, Cámara y SSD   que ademas conectado  mediante HDMI a una pantalla nos permitirá  disfrutar de una experiencia PC auténtica.

Anuncios

Nueva rom Android para Orange pi PC


Desde 2012 la Raspberry Pi ha ido  creciendo  de  gran popularidad, estando  hoy en día  posicionada como una de las placas de desarrollo de referencia. Uno de sus rivales clásicos en los últimos tiempos están siendo las Orange Pi, una placa con un diseño similar pero  basado  en  procesadores de Allwinne

Shenzhen Xunlong dispone de la  placa SBC  muy similar a la Raspberry Pi a falta de 1 conector  USB , pero con un coste   bastante inferior  en Aliexpres. Es ademas abierta y hackeable. La placa de desarrollo low cost compite abiertamente   con  otras tantas existentes  donde  la mas destacable es también la Banana Pi  ,  pretendiendo todas  ellas  competir  con la Raspberry Pi.

 

orangepi

 

Esta placa integra una CPU basada en ARM Cortex A7 Dualcore y Quadcore (en la versión más potente), una GPU Mali compatible con OpenGL y 1GB DDR3 RAM, posibilidad de direccionar hasta 64GB de almacenamiento mediante tarjetas o por un puerto SATA, conexiones para audio, conector CSI para cámara, HDMI, VGA, USB OTG, USB 2.0, alimentación, GPIOs, IR, AV, receptor de infrarrojos, Ethernet RJ45 10/100M, tres puertos USB 2.0, uno microUSB OTG, un micrófono, un interfaz CSI para cámara y un encabezado de 40 pines compatible con Raspberry Pi,etc

Sobre diferencias respecto  al original,ciertamente casi todas las placas SBC son bastante similares orientándose para ser clones  mas baratos  de  la Raspberry Pi. Es cuestión de gustos o necesidades, pues  como hemos visto no se pueden alegar diferencias sustanciales, excepto porque se basan en arquitecturas diferentes a la ARM (como las basadas en x86) de la cual se comenta tienden a calentarse mucho precisando normalmente de un radiador pasivo o si es posible mejor  activo (equipado con un miniventilador).

orange_pi

En cuanto a los sistemas operativos soportados, se encuentran Raspbian, Ubuntu, Debian, Android 4.4 y otras versiones del sistema de Google  descargable desde la pagina oficial .. Todos ellos pueden ser movidos por los chips de Allwinner y el hardware que entregan estas placas SBC (Single Board Computer).

 

Desde la pagina oficial hay una imagen para Android ,pero desgraciadamente no funciona, pero gracias a la comunidad que hay detrás de esta placa  se ha creado una nueva imagen que si es funcional  ,  la cual ademas intenta explotar al máximo el hw de esta placa.

Como el procedimiento de instalación de una imagen Android es ligeramente diferente a una imagen basada en Linux, vamos a ver como crearla.

Para crear la imagen necesitaremos los siguientes  elementos  software:

 

La  instalación de seta nueva ROM es sencilla :

  • Descargar  Android firmware http://sh.st/nJPLZ
  • Descomprimir el archivo con el winrar
  • Inserte una microsd en su PC
  • Abra Phoenix Suite, y seleccione el archivo de imagen que descargó y descomprimimos en los dos primeros pasos
  • Asegúrese que en disK aparece la unidad donde ha metido la sd ( si por error es otra unidad borraría su contenido)
  • Pulse  Format no Normal
  • Espere a que finalice el proceso
  • Chequee ahora el checkbox Startup!
  • Pulse  el boton  Burn!

 

 

phoenix.PNG

  • Tras unos minutos debería ver llegar hasta el final y concluir el proceso

phoenixfin

NOTA: si en este proceso del da  ERROR puede ser por la falta de capacidad  o por el tipo de memoria ( recomendable al menos una microsd HC de  16GB)

 

En la version del firmware  V1.2 incluye:

  • Librerías multimedia actualizadas
  • Actualizado mi librtmp personalizado en Kodi
  • Otras pequeñas …

Registro de cambios V1.1:

  • Todo lo anterior menos el kernel personalizado, no es necesario …
  • Basado en 202k4
  • Root actualizada
  • Busybox actualizado
  • Añadido Nano editor de texto. Abra Terminal y escriba nano
  • Añadido entorno Bash. Abrir terminal y tipo bash
  • Añadido soporte init.d.
  • Otras cosas pequeñas ….

Registro de cambios V1:

  • TWRP 2.8.7.0 (Thks Abdul_pt)
  • Kernel de tronsmart (julio) Configuración personalizada.
  • Xbox360 inalámbrico y soporte de cable.
  • Custom Kodi 14.2 CedarX Hw aceleración del código fuente zidoo (thks zidoo y kodi equipo) limpiar y eliminar todas sus protecciones!
  • ¡Actualizó todas las aplicaciones de Google!
  • Limpia todo lo que el dragón recurso eater spyware crap
  • Se agregaron algunas aplicaciones de preinstalación. Youtube, Terminal, Reboot, Explorador de archivos ES, AdAway …
  • Aumento de los búferes TCP
  • Se ha agregado un Nexus10 build.prop

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

Ajustes efecto Ambilight con Raspberry Pi


En un post anterior   vimos como  emular un sistema “ambiligt”  usando únicamente una Raspberry Pi 2  o 3  equipada con una distribución compatible ( Openelec)   y el software de control de  leds Hyperion, con el que podemos conseguir todo hecho  gracias a la distribución Lightberry. 
Además de controlar los leds, la combinación de la Raspberry Pi junto con Kodi constituye un excelente Media Center capaz de reproducir todo tipo de contenidos de audio, vídeo e imagen, de reproducir nuestra colección multimedia almacenada en el PC o en un disco externo, e incluso de reproducir directamente contenidos on-line si se posee  las  subscripción en el hogar  y por supuesto cuenta con la conexión  de suficiente ancho de banda como por ejemplo con ftth.

 La propuesta se completa  con una económica  capturadora  de vídeo  que permitirá  que la emulación no solo funcione con el contenido multimedia que reproducimos desde la Raspberry Pi  , también  responderá a la señal de video externa que le introduciremos  procedente de una fuente externa de video como por ejemplo puede ser la señal de video procedente de un descodificador de Imagenio .

 

Por desgracia a veces la respuesta del Hypercon que  produce en la tira de leds ws2801 no se corresponde  con la imagen capturada , señal que el el fichero obtenido por el asistente (hypercon.config.son ) deberíamos mejorarlo ¿pero cómo?
Pues gracias al programa en java  HyperCon   podemos indicar  la posición exacta de nuestros leds en el caso de que la configuración realizada desde el menu de Hyperion Config Creator   no haya  ofrecido un resultado esperado .

Este software permite entre otras cosas establecer el número de leds que hay que controlar, la posición del primer led, la orientación, el chipset, etc…permitiendo un ajuste muy preciso del comportamiento de cada led de forma individual

Antes de seguir, quiero aclarar para que HyperCon.jar funcione, es necesario tener instalada la ultima version de  Java ,asi que si no la tiene  instalada puede descargarlo aquí

Recordamos que con el menu basico de  Hyperion Config Creator   podemos  definir la instalación de nuestra  Lightberry en nuestra TV   definiendo simplemente 5 parámetros:
  • Tipo de tira de leds: en nuestro casi   podemos elegir  Lightberry HD for Rasperry pi (ws2801)
  • Numero de leds horizontales ( deben ser idéntico numero de leds  en ambos lados)
  • Numero de leds  verticales   ( deben ser idéntico numero de leds  en ambos lados)
  • Donde comienza el primer led (Right/button corner and goes up)
  • Confirmación  de  que tenemos un capturadora de TV conectada

Puede ocurrir que aunque  veamos el arco iris con la configuración obtenida  no se correspondan los colores de los leds con los de la imagen , indicio de que debemos ajustar la configuración manualmente  de forma mas  precisa  por medio del archivo hyperion.config.json  generado por el asistente  de un modo mas exhaustivo usando  el programa en java  HyperCon  o bien de forma manual.

Obviammente para ejecutar dicha aplicacion, como se ha mencionado ,debemos tener instalado en nuestro equipo java

Una vez descomprimido el  pquete de Hypercon , simplemente ejecutaremos el archivo HyperCon_Sssj.jar  ( este fichero estará por ejemplo  en la ruta C:\Users\xx\Downloads\hypercon-master\hypercon-master\debug\)

hypercon

Una vez lanzado el hypercon veremos el interfaz  gráfica con una configuración por defecto que debemos personalizar   con respecto a nuestra instalación.

Debe recodar donde puso el primer led (el que está al lado del conector hembra con los jumpwires).

pantalla

En este ejemplo personal ,el primer led   ha quedado en la esquina inferior derecha cuando se mira la TV de frente ( o a la izquierda abajo si ve por atras), así que el recorrido de los leds va desde la esquina inferior  derecha hasta la izquierda (sentido horario).

Configuramos de este modo:

  •  Direction: clockwise
  •  Led top corner: false
  •  Led bottom corner: false
  •  Horizontal #: 28
  •  Vertical #: 14
  •  Bottom Gap: 0
  •  1st Led offset: -42

En nuestro caso tiene que salir un Led count = 84 (o el número de leds que haya instalado).

Si en su configuración  empezó  por la otra esquina, cambie el desplegable  direction.

En el caso del ejemplo  no se han situado leds en las esquinas, así que hay que especificar  top/bottom a false.

En bottom gap hay que poner el mismo numero de leds que en la parte superior, así lo puede dejar “vacío”.

Muy importante : en  el desplegable  1st Led offset hay que ir aumentando o disminuyendo hasta que el led número 0 quede en la esquina inicial (en este ejemplo en la esquina inferior derecha).

pantalla.png

Una vez configurado según los leds que tenga, vaya a la pestaña External y en el apartado Effects Engine Directory  escriba lo siguiente: /storage/hyperion/effects lo cual  hará que hyperion encuentre el directorio de los efectos.

Asimismo puede ajustar el tiempo en ms que permanezca el efecto al arrancar  en Length ( por defetco 9000ms)

rain

Una vez configurado haz clic en el botón Create Hyperion Configuration para crear el fichero de configuración hyperion.config.json que hay que copiar  en la Raspberry PI en el directorio /storage/.config     (   no confundir  con  la ruta /storage/hyperion/configuration/)

hyperion .

Una vez copiado el fichero  hyperion.config.json en storage/.config reinicie la RPI y si todo ha ido bien deberías ver un efecto de arcoiris.

Configuracion inicial

La configuración del dispositivo contiene los siguientes campos:

  •  ‘name’: El nombre de usuario del dispositivo (sólo se utiliza para fines de visualización)
  •  ‘type’: El tipo del dispositivo o leds (los tipos conocidos por ahora son ‘ws2801’, ‘ldp8806’, ‘ ‘lpd6803’, ‘sedu’, ‘adalight’, ‘lightpack’, ‘test’ y ‘none’)
  • output : La especificación de salida depende del dispositivo seleccionado. Esto puede ser, por ejemplo, el especificador de dispositivo, número de serie del dispositivo o el nombre del archivo de salida
  • rate’: El baudrate de la salida al dispositivo
  • colorOrder’: El orden de los bytes de color (‘rgb’, ‘rbg’, ‘bgr’, etc.).Es muy  importante destacar que si no ajustamos este valor  se pueden cambiar el borde de los colores .Por ejemplo muchas tiran son del t tipo BGR, lo cual significa que si dejamos marcado por defecto en RGB  cambiará en todas las visualizaciones el rojo por el azul y biceversa

Ejemplo de configuración  de la sección  device correspondiente al post anterior  :

“device”: {
“colorOrder”: “bgr”,
“rate”: 500000,
“type”: “ws2801”,
“name”: “MyPi”,
“output”: “/dev/spidev0.0”
},

Color

Podemos manipular la  configuración de manipulación de color utilizada para ajustar los colores de salida a un entorno específico.
La configuración contiene una lista de transformaciones de color. Cada transformación contiene  los  siguientes campos:

  •  ‘id’: El identificador único de la transformación de color (p. Ej. ‘Device_1’)
  • ‘leds’: Los índices (o índices) de los leds a los que se aplica esta transformación de color  (por ejemplo, ‘0-5, 9, 11, 12-17’). Los índices son basados ​​en cero.
  •  ‘hsv’: La manipulación en el dominio de colores Valor-Saturación-Valor con lo siguiente  parámetros de ajuste:
    •  ‘saturationGain’ El ajuste de ganancia de la saturación
    • ‘valueGain’ El ajuste de ganancia del valor
  • ‘rojo’ / ‘verde’ / ‘azul’: La manipulación en el dominio de color Rojo-Verde-Azul con los  siguientes parámetros de sintonización para cada canal:
    •  ‘umbral’ El valor de entrada mínimo requerido para que el canal esté encendido
      (más cero)
    •  ‘gamma’ El factor de corrección de la curva gamma
    •  ‘blacklevel’ El valor más bajo posible (cuando el canal es negro)
    •  ‘whitelevel’ El valor más alto posible (cuando el canal es blanco)

Al lado de la lista con transformaciones de color también hay una opción de suavizado.
‘Suavizado’: Suavizado de los colores en el dominio del tiempo con la siguiente sintonización  parámetros:

  • ‘type’ El tipo de algoritmo de suavizado (‘linear’ o ‘none’)
  •  ‘time_ms’ La constante de tiempo para el algoritmo de suavizado en milisegundos
  •  ‘updateFrequency’ La frecuencia de actualización de los leds en Hz

Ejemplo de configuración  de la seccion color  correspondiente al post anterior  

“color”: {
“transform”: [
{
“blue”: {
“threshold”: 0.050000000000000003,
“blacklevel”: 0.0,
“whitelevel”: 0.84999999999999998,
“gamma”: 2.0
},
“leds”: “0-81”,
“hsv”: {
“saturationGain”: 1.0,
“valueGain”: 1.0
},
“green”: {
“threshold”: 0.050000000000000003,
“blacklevel”: 0.0,
“whitelevel”: 0.84999999999999998,
“gamma”: 2.0
},
“id”: “leds”,
“red”: {
“threshold”: 0.050000000000000003,
“blacklevel”: 0.0,
“whitelevel”: 1.0,
“gamma”: 2.0
}
},
{
“blue”: {
“threshold”: 0.050000000000000003,
“blacklevel”: 0,
“whitelevel”: 0,
“gamma”: 2.0
},
“leds”: “82-149”,
“hsv”: {
“saturationGain”: 0,
“valueGain”: 0
},
“green”: {
“threshold”: 0.050000000000000003,
“blacklevel”: 0,
“whitelevel”: 0,
“gamma”: 2.0
},
“id”: “ledsOff”,
“red”: {
“threshold”: 0.050000000000000003,
“blacklevel”: 0,
“whitelevel”: 0,
“gamma”: 2.2000000000000002
}
}
],

Leds

La configuración para cada led individual. Contiene la especificación del área  promediado de una imagen de entrada para cada led para determinar su color. Cada elemento de la lista  contiene los siguientes campos:

  •  index: El índice del led. Esto determina su ubicación en la cadena de leds; cero
    Siendo el primer led.
  •  hscan: La parte fraccional de la imagen a lo largo de la horizontal utilizada para el promedio  (mínimo y máximo inclusive)
  •  vscan: La parte fraccional de la imagen a lo largo de la vertical utilizada para el promedio  (mínimo y máximo inclusive)
  •  ‘updateFrequency’ La frecuencia de actualización de los leds en Hz


“leds” :
[
{
“index” : 0,
“hscan” : { “minimum” : 0.0000, “maximum” : 0.0500 },
“vscan” : { “minimum” : 0.0000, “maximum” : 0.0800 }
},
{
“index” : 1,
“hscan” : { “minimum” : 0.0000, “maximum” : 0.0357 },
“vscan” : { “minimum” : 0.0000, “maximum” : 0.0800 }
},

…………………..

{
“index” : 87,
“hscan” : { “minimum” : 0.0000, “maximum” : 0.0500 },
“vscan” : { “minimum” : 0.0000, “maximum” : 0.0714 }
}
],

Configuracion Bordes

La configuración de borde negro, contiene los siguientes elementos:

  •  enable: true si el detector debe ser activado
  •  Umbral: valor por debajo del cual un píxel se considera negro (valor entre 0,0 y 1,0)
    “Blackborderdetector”:

Ejemplo de configuración  de la seccion blackborderdetector correspondiente al post anterior  

“blackborderdetector”: {
“threshold”: 0.10000000000000001,
“enable”: true
},

EFECTOS

La configuración del motor de efectos, contiene los siguientes elementos:

  • paths: Una matriz con ubicaciones absolutas de directorios con efectos
  • bootsequence: El efecto seleccionado como ‘secuencia de arranque’. Es importante cambiar a su valor en OpenElec  “/storage/hyperion/effects”

Ejemplo de configuración sección  effects correspondiente al post anterior  :

“effects”: {
“paths”: [
“/storage/hyperion/effects”
]
},

CAPTURADORA

La configuración del captador de tramas, contiene los siguientes elementos:

  •  width: El ancho de los marcos grabados [pixels]
  •  height: La altura de los marcos grabados [pixels]
  • frequency_Hz: La frecuencia de la toma de marco [Hz]

La configuración de la conexión XBMC utilizada para habilitar y deshabilitar el captador de tramas. Contiene los siguientes campos:

  •  xbmcAddress: La dirección IP del host XBMC
  •  xbmcTcpPort: El puerto TCP del servidor XBMC
  • grabVideo: Flag  que indica que el captador de fotogramas está activado (true) durante la reproducción de vídeo
  •  grabPictures: Flag que indica que el captador de fotogramas está activado (true) durante la presentación de imágenes
  •  grabAudio: Flag que indica que el captador de fotogramas está activado (true) durante la reproducción de audio
  •  grabMenu: Flag que indica que el captador de fotogramas está activado (true) en el menú XBMC
  •  grabScreensaver: Flag que indica que el captador de fotogramas está activado (true) cuando XBMC está en el salvapantallas
  •  enable3DDetection: Indicador que indica que el captador de fotogramas debe cambiar a un modulo compatible con 3D si se está reproduciendo un video en 3D

Ejemplo de configuración sección  effects correspondiente al post anterior  :

 “framegrabber”: {
“width”: 64,
“frequency_Hz”: 10.0,
“height”: 64
},
“xbmcVideoChecker”: {
“grabVideo”: true,
“grabPictures”: true,
“xbmcTcpPort”: 9090,
“grabAudio”: true,
“grabMenu”: false,
“enable3DDetection”: true,
“xbmcAddress”: “127.0.0.1”,
“grabScreensaver”: true

NOTAS

Si no quiere reiniciar lar RPI cada vez que modifique el fichero de configuración hyperion.config.json, puede reiniciar sólo el servicio con los siguientes comandos:

killall hyperiond
/storage/hyperion/bin/hyperiond.sh /storage/.config/hyperion.config.json /dev/null 2>&1 &

Hay que añadir la siguiente línea dtparam=spi=on al archivo config.txt  editando el fichero o bien a través con los siguientes comandos:

mount -o remount,rw /flash
nano /flash/config.txt (se abrirá el archivo, añadimos la línea y guardamos con Ctrl+X)

reboot

Pruebas

Para comprobar el correcto funcionamiento del sistema para Android existe una app que te permite controlar los leds estableciendo un color o aplicando efectos bastante vistosos. La puede descargar aquí

hype

Otra forma de probar es ejecutando el siguiente comando que hará que todos los leds se iluminen en rojo durante 5 segundos, puedes probar varios colores, green, blue entre otros.

/storage/hyperion/bin/hyperion-remote.sh –priority 50 –color red –duration 5000

O este otro que mostrará un efecto de arcoiris

/storage/hyperion/bin/hyperion-remote.sh  –effect “Rainbow swirl fast” –duration 3000

Por ultuio en youtube puede encontrar vídeos de test para probar que los colores se corresponden con la imagen.

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

 

 

Diagnosis de su coche con Raspberry Pi


OBD-II PID ( Diagnóstico a bordo de parámetros IDs ) son códigos utilizados para solicitar datos de un vehículo, que se utiliza como herramienta de diagnóstico  que tradicionalmente se ha reservado a los  técnicos automotrices que usan PID con una herramienta de análisis conectado al conector OBD-II del vehículo.

  • El técnico entra en el PID
  • La herramienta de análisis lo envía al del vehículo red controlador-área (CAN) la parada de microbus, VPW, PWM, ISO, KWP . (Después de 2008, sólo CAN)
  • Un dispositivo en el bus reconoce el PID como uno es responsable de, y reporta el valor para ese PID al bus
  • La herramienta de análisis lee la respuesta, y lo muestra al técnico

Un  adaptador   OBD-II  funciona  en cierta manera  como el USB de un ratón que usamos con el ordenador, ya que se conecta a la centralita del coche y convierte los datos que lee en información que podemos procesar desde nuestro móvil.

Estos adaptadores se puede encontrar  fácilmente en internet y a precios que empiezan en los 6 euros y van subiendo hasta los varios cientos, dependiendo de la calidad y cantidad de opciones que necesitemos. Pero para un uso completamente ‘amateur‘, tenemos suficiente con los más económicos. Eso sí, antes de comprarlo debe   compruebe que la centralita de su coche tiene la conexión de 16 pines del estándar y es compatible  con dicho  interfaz.

 

 

Adaptadores ODB2 bluetooth

elm37

Algunas centralitas de vehículos puede soportar más o menos funciones que otros.,pero en todo caso  no olvide  que la aplicación necesita un adaptador Bluetooth OBD2 para trabajar.

Estos  adaptadores  son  pequeños y se conectan a la toma de diagnóstico en el coche que le da a su acceso a los teléfonos.Uno de los adaptadores mas usados  es el modelo el ELM327 OBD2 el cual funciona igual de bien que otros aparatos similares de tamaño mucho mayor y   aún precio bastante menor (como por ejemplo el  adaptador Scantool.net, el adaptador de OBDKey y PLX Kiwi ).

El modelo ELM 327  es el clásico lector de parámetros del motor y de códigos de error OBD II mini, en carcasa de plástico transparente  de  reducido tamaño(otros modelos mayores  estorban en la zona de los pedales)   que es capaz de enviar los datos vía Bluetooth   y que se puede adquirir  a muy buen precio.

Para usarlo, hay que enchufar el dispositivo  al conector que suelen traer casi todos los coches modernos  junto a la fusiblera principal que suele estar  debajo del volante.

Después hay que instalar  la aplicación  Torque en su smartphone   ( en su versión gratuita o de pago )  y automáticamente al ejecutarla  debería empezar a ver en la app  una cantidad ingente  de información sobre el funcionamiento de su vehículo.

Los usuarios  se abruman   del  impresionante volumen de datos aportado pues aplicación es 100% configurable para mostrar los parámetros que prefiera. De hecho los datos ofrecidos son prácticamente similares a una maquina de diagnosis de cualquier taller en sus manos, aportando ademas de un sinfin de parámetros informativos sobre el estado de motor, consumos, temperaturas, posibles averías etc

Resumidamente  estas son algunas de las utilidades  de la combinación  del adaptador  ELM327 OBD2 junto con el programa  Torque:

  • Leer los códigos diagnóstico, genéricos y específicos del fabricante, y mostrar su significado (sobre 3000 definiciones genéricas del código en la base de datos).
  • Borrar los códigos de problemas y apagar el MIL (“Check Engine” de luz)
  • Mostrar los datos actuales del sensor

Según el modelo de coche podrá ver más o menos datos, pues eso no depende de este aparato  en su .De hecho ,hay usuarios que no han conseguido hacerlos funcionar con determinados modelos de vehículos, pero en cambio en otros modelos  funciona perfectamente:

 

Por cierto ,esta versión  del  ELM327  se puede comprar por menos de 6€  con gastos de envió incluidos  aqui (Amazon.es)

Adaptadores ODB2 USB

Hay muchos ejemplos de entusiastas que  están usando estos adaptadores ODB2 no solo desde dispositivos Android sino incluso desde PC standard ,pero ¿ y si se pudiera usar desde otros dispositivos  como por ejemplo desde una Raspbery Pi?

Pues en  efecto desde pistonheads.com  nos demuestra como es posible desde una RPi de  leer datos de su moto a través de un lector USB OBD-II  usando  como registrador de datos para una moto gracias  a que cabe perfectamente  debajo del asiento

Para ello , se usa un   cable USB -> OBD2 , el cual  soporta muchas versiones diferentes del puerto estándar OBD2

La RPi toma la  alimentación  una conexión micro del USB que se alimenta a su vez  de la batería (lo ideal es desde luego hacerlo desde  la llave de encendido / apagado, pero esto llevar mucho más trabajo y se corre el peligro de  dañar el cableado de la moto) así que el usuario opto  por compro un interruptor y un fusible  que  termina en un puerto USB hembra lo cual permite  apagar la RPpi al final de un viaje

Lo siguiente es  el código, basado en  la  librería python  desarrolla en 2009 llamado pyobd. Esta fue  la  base para lo que quería hacer, encontrando algunos errores en el código pues , en general, estaba escrito para ser utilizado por una aplicación  grafica GUI que venía con ella. Como el autor no quería una aplicación GUI, obviamente, bajo su asiento se bajo su repositorio y comenzó a trabajar en hacerlo más parecido a un datalogger

El trabajo esta en su  repositorio : https://github.com/roflson/pyobd

 

Gracias al trabajo excelente de Salgar , Martin quiso ir mas lejos  conectando ademas una cámara ,    utilizando  los datos OBD para superponer mph, rpm, temperatura y la posición del acelerador sobre el vídeo tomado con la placa de la cámara construyendo realmente un dispositivo bastante interesante

Resumidamente  el  proceso de desarrollo de  la nueva herramienta fue muy similar a la anterior adaptación de Salgar , basándose también en un  adaptador  USB al cable de interfaz de OBD2 del tipo ELM 327 1.5V USB CAN-BUS Scanner ELM327 , por cerca de £ 10 disponibles en  amazon.com o amazon.co.uk .( en España un no esta )

Otro elemento importante es conectar la cámara a su Raspberry Pi 2 usando el conector propietario especifico

Un modelo asequible compatible con la Raspberry Pi2   es el Módulo de cámara Raspberry Pi de SainSmart  que cuesta unos 14€ 

 

Luego  una vez adquirido el hardware , descargo el  software de salgar de su repositorio github, https://github.com/roflson/pyobd , como base para el nuevo programa (el software de salgar es una bifurcación de un proyecto llamado pyobd, https://github.com/peterh/pyobd , que es una aplicación basada en GUI para leer datos OBD-II).

Utilizo el autor  este  nuevo software  como base para un programa que se conectaría a través de la interfaz OBD-II, interrogando al coche qué sensores soportaba y luego leyendo los sensores de datos en un bucle cada 0,5 segundos  escribiéndolos en la pantalla de modo que la RP2 no solo registra el video , también registra  los  datos dinámicos superponiendolos al video cumpliendo pues una doble función

Descargar y ejecutar

El autor   finalmente  ha puesto a la disposición de todos los usuarios su  sw  de modo que puede descargar el código directamente desde github  en ,https://github.com/martinohanlon/pyobd ,

 

Resumidamente estas son las instrucciones de instalación:

 

Si le “pica”la curiosidad en el vídeo podemos ver la Rp2 con el sw en acción

Acceso web de Sensores Analogicos para Raspberry Pi (parte 2)


En un post anterior veíamos algunas de las posibilidades de  conexión de sensores digitales  a nuestra Raspberry Pi como puede ser añadir sensores I2C con el CI DS1820 , sensores de Co2 basados en el Mq4, sensores genéricos,sensores de de presión con el BMP180,sensores de temperatura basados en el TMP102, sensores de proximidad basados en el VCNL 4000o  o los sensores de luminosidad basados en el  TSL2561.

Como todos sabemos  existen también una cantidad muy alta de sensores cuya salida no es digital , lo cual en principio no se podrian conectar directamente a nuestra Raspberry, pero esto no es exactamente asi, porque si podemos conectarlos por medio de convertidores A/D y D/A  y otros circuitos como vamos a ver  (y empezamos a  ver en un post  posterior ).

Retomamos nuevamente el mundo analógico y la Raspberry Pi  con mas ejemplos :

 

MCP23017

MCP23017

 Este CI  de coste  contenido  permite agregar 16 salidas a una placa  conectándola al puerto I2C. La conexión es sencilla como vamos a  ver  a continuación

Use el siguiente diagrama para conectar el MCP23017 IO expansor.

Paso 1

Desde el  Pi para alimentar VDD (pin 9) en el MCP23017.
MCP23017

Paso 2

Conectar tierra  de Pi al VSS (pin 10) en el MCP23017.
MCP23017

Paso 3

Conectar los pines SCL del MCP23017 (pin 12) a la Pi.
MCP23017

Paso 4

Conecte las clavijas SDA de la MCP23017 (pin 13) a la Pi.
MCP23017

Paso 5

Conectar toma de tierra a los pines de dirección (pin 15, 16, 17) en el MCP23017. Esto le dará el expansor de una dirección predeterminada de 0 x 20.
MCP23017

Paso 6

Para el Reset (pin 18) en el MCP23017 . Debe conectar  el pin de Reset  para el funcionamiento normal.
MCP23017

Paso 7

¡Listo! Ahora puede Agregar el MCP23017 en el panel de Caynne, con dirección por defecto de 0 x 20.

MCP23009

MCP23009

 El MCP23009-E / SS es un expansor de E / S de 8 bits con salidas de drenaje abierto. Consiste en múltiples registros de configuración de 8 bits para la selección de entrada, salida y polaridad. El maestro del sistema puede habilitar E / S como entradas o salidas escribiendo los bits de configuración de E / S. Los datos de cada entrada o salida se guardan en el registro de entrada o salida correspondiente. La polaridad del registro del puerto de entrada puede invertirse con el registro de inversión de polaridad. Todos los registros pueden ser leídos por el maestro del sistema. El registro de captura de interrupción captura los valores de puerto en el momento de la interrupción, ahorrando así la condición que causó la interrupción. El restablecimiento de encendido (POR) ajusta los registros a sus valores predeterminados e inicializa la máquina de estado del dispositivo. El pin de dirección de hardware se utiliza para determinar la dirección del dispositivo.

Use el siguiente diagrama para conectar su MCP23009 IO expansor.

Paso 1

Desde el pastel de Pi para alimentar VDD (pin 1) en el MCP23009.
MCP23009

Paso 2

Conectar la tierra de la Pi a VSS (pin 18) en el MCP23009.
MCP23009

Paso 3

Conectar los pines SCL de la MCP23009 (pin 3) y la Pi.
MCP23009

Paso 4

Conecte las clavijas SDA de la MCP23009 (pin 4) y la  Pi.
MCP23009

Paso 5

Conectar toma de tierra al pin de dirección (pin 5) en el MCP23009. Esto le dará el expansor de una dirección predeterminada de 0 x 20.
MCP23009

Paso 6

Alimentar el reset (pin 6) en el MCP23009. Conectar  Reset es necesario para el funcionamiento normal.
MCP23009

Paso 7

¡Listo! Ahora puede Agregar el MCP23009 en el panel de cayenne, con dirección por defecto de 0 x 20.

MCP23008

MCP23008

Es un circuito muy similar al anterior que  nso proporciona 8 entradas  o salidas  binarias a traves del SDA

Use el siguiente diagrama para conectar su MCP23008 IO expansor.

Paso 1

Conecte las líneas de energía, conectando a VDD (pin 18) en el MCP23008.
MCP23008

Paso 2

Conecte las líneas de tierra, conexión de tierra al VSS (pin 9) en el MCP23008.
MCP23008

Paso 3

Conecte las clavijas SDA de la MCP23008 (pin 2) y la  Pi.
MCP23008

Paso 4

Conectar los pines SCL de la MCP23008 (pin 1) y la  Pi.
MCP23008

Paso 5

Conectar toma de tierra a los pines de dirección (pines 3, 4, 5) en el MCP23008. Esto le dará el expansor de una dirección predeterminada de 0 x 20.
MCP23008

Paso 6

Alimentar el reset (pin 6) en el MCP23008. Conectar el pin Reset es necesario para el funcionamiento normal.
MCP23008

Paso 7

¡Listo! Ahora puede Agregar el MCP23008 en el  panel de control de Cayenne, con dirección por defecto de 0 x 20.

DS2408

ds2408

 El DS2408 es un chip de E / S 1-Wire® programable de 8 canales. Las salidas PIO se configuran como drenaje abierto y proporcionan una resistencia de 100Ω máx. Un protocolo de comunicación de acceso de canal PIO robusto garantiza que los cambios de configuración de salida PIO se produzcan sin errores. Se puede utilizar una salida estroboscópica válida para datos para bloquear estados lógicos PIO en circuitería externa tal como un convertidor D / A (DAC) o un bus de datos de microcontrolador.

Un par de notas antes de comenzar:

  • Para aprovechar las ventajas de la detección automática de cayena de dispositivos 1-wire, conecte a 4 GPIO.
  • Asegúrese de que Raspberry Pi está apagado al conectar los cables.
  • Cuando utilice un cable de cinta GPIO, asegúrese de que está conectado el cable (es un color diferente que los otros) en la esquina de la Raspberry Pi y la parte superior de tu pastel de Pi.
  • El diagrama proporcionado es sólo un ejemplo de cómo conectar el sensor. Hay muchas maneras para conectar sensores y extensiones, así que trate de lo que funciona mejor para usted!
  • Algunos placas de prototipos (usados en los diagramas a continuación) tienen una  linea de alimentación  que se separa en el medio. Si este es el caso, asegúrese de que sus sensores están conectados en la misma mitad de la placa como el Pi.

Use el siguiente diagrama para conectar su DS2408 “1-Wire” IO expansor.

Paso 1

Desde el  Pi alimentar el DS2408 VCC (pin 3). Asegúrese de que añade  una resistencia de pull-up entre la potencia (pin 3) y pines de datos (pin 4) en el DS2408.
DS2408

Paso 2

Conectar la tierra del Pi a la tierra de DS2408 (pin 5).
DS2408

Paso 3

Conectar la clavija de control DS2408 en GPIO Pin 4 en el Pi. Conexión a 4 GPIO permite la detección automática .
DS2408

Paso 4

¡Listo! Encienda su frambuesa Pi y el agente Cayenne automáticamente detectará el expansor DS2408 y agregara este a su panel de control.

MCP23S09

MCP23S09

 El MCP23S09-E / P es un expansor de E / S de 8 bits con salidas de drenaje abierto. Consiste en múltiples registros de configuración de 8 bits para la selección de entrada, salida y polaridad. El maestro del sistema puede habilitar E / S como entradas o salidas escribiendo los bits de configuración de E / S. Los datos de cada entrada o salida se guardan en el registro de entrada o salida correspondiente. La polaridad del registro del puerto de entrada puede invertirse con el registro de inversión de polaridad. Todos los registros pueden ser leídos por el maestro del sistema. El registro de captura de interrupción captura los valores de puerto en el momento de la interrupción, ahorrando así la condición que causó la interrupción. El restablecimiento de encendido (POR) ajusta los registros a sus valores por defecto e inicializa la máquina de estado del dispositivo. El pin de dirección de hardware se utiliza para determinar la dirección del dispositivo.

Use el siguiente diagrama para conectar su Convertidor A/D de MCP23S09 con interfaz de SPI.

Paso 1

Alimentar desde el  Pi al MCP23S09 pin 1 (VDD) y pin 7 (RESET).
MCP23S09

Paso 2

Conectar la tierra del  Pi al MCP23S09 pin 18 (VSS).
MCP23S09

Paso 3

Conecte la clavija de entrada MCP23S09 chip select (CS) de 3 a uno de los pines del chip select del Pi  CE0 en este ejemplo.
MCP23S09

Paso 4

Conectar patillas SCLK del  Pi y el MCP23S09 4 (SCK).
MCP23S09

Paso 5

Conectar patillas MOSI del Pi y el MCP23S09 5 (SI).
MCP23S09

Paso 6

Conectar patillas MISO del Pi y el MCP23S09 6 (SO).
MCP23S09

Paso 7

¡Listo! Ahora puede Agregar el convertidor de MCP23S09 a tu panel de control usando el chip-select 0.

MCP23S08

MCP23S08

 El MCP23S08 es un “8-Bit I / O Expander con el interfaz de SPI” IC de Microchip . Este dispositivo también está disponible en variaciones I2C (MCP23008) y 16 bits (MCP23x17),

Use el siguiente diagrama para conectar su convertidor A/D de MCP23S08 con interfaz de SPI.

Paso 1

Alimentar desde el  Pi al MCP23S08 pin 18 (VDD) y la clavija 6 (RESET).
MCP23S08

Paso 2

Conectar la tierra del pastel de Pi al MCP23S08 pin 9 (VSS).
MCP23S08

Paso 3

Conectar patillas SCLK del Pi y el MCP23S08 pin 1 (SCK).
MCP23S08

Paso 4

Conectar patillas MOSI del  Pi y el MCP23S08 pin 2 (SI).
MCP23S08

Paso 5

Conectar patillas MISO del  Pi y el MCP23S08 pin 3 (SO).
MCP23S08

Paso 6

Conecte los dos de los pines de dirección de MCP23S08 (pines 4, 5) a tierra. Esto resultará en una dirección predeterminada de 0 x 20.
MCP23S08

Paso 7

Conecte la clavija de entrada MCP23S08 chip select (CS) pin 7 a uno de los pines del chip select Pi , CE0 en este ejemplo.
MCP23S08

Paso 8

¡Listo! Ahora puede Agregar el convertidor de MCP23S08 a su panel de control  de Cayenne usando el chip-select (pin  0).

MCP23S18

MCP23S18

Hablamos de un chip del fabricante MICROCHIP  que es un  Expansor de E/S de 16bit funcionando a  10 MHz con interfaz  SPI

Use el siguiente diagrama para conectar su Convertidor A/D de MCP23S18 con interfaz de SPI.

Paso 1

Alimentar de la Pi  a RESET (pin 16) y VDD (pin 11) en el MCP23S18.
MCP23S18

Paso 2

Conectar la tierra del  Pi a VSS (pin 1) en el MCP23S18.
MCP23S18

Paso 3

Conectar patillas SCLK del  Pi y el MCP23S18 13 (SCK).
MCP23S18

Paso 4

Conectar patillas MOSI del  Pi y el MCP23S18 14 (SI).
MCP23S18

Paso 5

Conecte la clavija de entrada MCP23S18 chip select (CS) del pin  12 a uno de los pines del chip select Pi Zapatero, CE(pin 0 )en este ejemplo.
MCP23S18

Paso 6

Conectar patillas MISO del  Pi y el MCP23S18 pin 15 (SO).
MCP23S18

Paso 7

¡Listo! Ahora puede Agregar el convertidor de MCP23S18 a tu panel de control de Cayenee usando el chip-select 0.

MCP23S17

MCP23S17

Hablamos de un chip del fabricante MICROCHIP  que es un  Expansor de E/S de 16bit funcionando a  10 MHz con interfaz  SPI

 El MCP23s08 y MCP23s17 tiene 3 bits de selección de direcciones por lo que en teoría se puede conectar hasta 8 MCP23s08 y MCP23S17 en la misma señal de selección SPI que le da una capacidad GPIO de una señal adicional de 128 pines por SPI seleccionar cuando se utilizan estos dispositivos. (O el doble que si utiliza 8 más en la 2 ª SPI seleccionar)

Use el siguiente diagrama para conectar su Convertidor A/D de MCP23S17 con interfaz de SPI.

Paso 1

Desde el  Pi alimentar VDD (pin 9) en el MCP23S17.
MCP23S17

Paso 2

Conectar la tierra del  Pi a VSS (pin 10) en el MCP23S17.
MCP23S17

Paso 3

Conecte la clavija de entrada MCP23S17 chip select (CS) del pin  11 a uno de los pines del chip select Pi Zapatero, CE0 en este ejemplo.
MCP23S17

Paso 4

Conectar patillas SCLK del  Pi y el pin 12 del MCP23S17  (SCK).
MCP23S17

Paso 5

Conectar patillas MOSI del  Pi y el  pin 13 del MCP23S17 (SI).
MCP23S17

Paso 6

Conectar patillas MISO del  Pi y el pin  14 del MCP23S17  (SO).
MCP23S17

Paso 7

Conectar toma de tierra a los pines de dirección de MCP23S17 (15, 16, 17). Esto le dará el expansor de una dirección predeterminada de 0 x 20.
MCP23S17

Paso 8

Alimentar al pin de RESET (pin 18) en el MCP23S17. Conectar  el pin de Reset es necesario para el funcionamiento normal.
MCP23S17

Paso 9

¡Listo! Ahora puede Agregar el convertidor de MCP23S17 a su panel de control usando el chip-select 0.

 

Por cierto , para  mas información sobre como configurar el panel de control de Cayenne  , puede encontrar mas información en ingles  aqui