Construya su huerto robotico


En efecto   ya es posible  construirse   un huerto robótico ,  donde incluso el sw de gestión es open sw y cuyo cerebro no podía ser otro que una Raspberry Pi 3  .

Evidentemente para llevarlo a  la praxis realmente la barrera no es otra que el exigente hardware para controlar el huerto en si , pues este requiere  de una gran cantidad de elementos  que sin duda hacen mucho mas complejo  su construcción ,pero la buena  noticia  es que   aproximadamente FarmBot (que es la empresa que hay detrás de las idea)  prometen simplificarlo mediante diferentes kits  si esta dispuesto a  realizar una inversión entre 2595$ ( la version standard) o la 3795$ ( la version XL)

Aparte del potente hardware que funciona a modo de un puente grúa  con un cabezal multiherramienta bastante original llama la atención el sw para controlarlo bajo el concepto de arrastrar y soltar donde se puede diseñar gráficamente una granja arrastrando y colocando las plantas en el mapa  desde un interfaz que se  aprende en pocos minutos , por  lo que llevar a la plantación como podemos ver es bastante sencillo ya  que se tendrá todo previsto en todo momento cuando llegue la temporada de cultivo.

Es evidente que unos de los valores mas apreciados en el sw es que permite construir nuevas características,crear  código de propios mods personalizados o soportar  la aplicación web localmente  para ser independiente de la red. Ademas todo el software está bajo la licencia MIT en código abierto (open software)  y este esta compartido en Github , permitiéndole contribuir, copiar, modificar, redistribuir e incluso vender software FarmBot. ¿desea ayudar a crear nuevas funciones o tiene un error que reportar? ¡ Involúcrese en github!

 

En  el sw ademas  se contemplan regímenes de crecimiento  para construir pautas para el cuidado de una planta a lo largo de toda su vida mediante la programación de las secuencias a ejecutar cuando la planta es de una cierta edad. Incluso  los regímenes se pueden reutilizar, haciendo una brisa de replantación. Otro aspecto son las secuencias de construcción donde rápidamente se pude crear secuencias personalizadas para aprovechar al máximo su hardware donde ningún código es requerido. Simplemente arrastrar y soltar las operaciones básicas  ajustar los parámetros y guardar.

Ademas   el control se hace en tiempo real debido a que se pueden  utilizar  las  herramientas en tiempo real con los controles manuales. !Incluso se puede ahuyentar aves en tiempo real ordenándolo desde un smartphone  !

El Hardware ha pasado por grandes esfuerzos al diseño, fabricación y controles de calidad  siendo además, todos los modelos de CAD  públicos así que usted puede construir sus propias piezas.

Respecto  a  los elementos el hw ( que incluyen ambos kits)  estos son los elementos que lo   componen:

  • Extrusiones de aluminio para las pistas, pórtico y eje z
  • Placas de aluminio de 5mm anodizado
  • V-ruedas con rodamientos de bolas de goma sellada de acero inoxidable
  • Moldeado de inyección UV estabilizado componentes de plástico ABS
  • Tornillos de acero inoxidable, tuercas t, separadores y otros hardware
  • Cuatro motores de pasos NEMA 17 con codificadores rotatorios y cables
  • GT2 de correas y poleas de aluminio
  • Portacables de plástico durable
  • Acero inoxidable leadsrew y delrin bloque de 8mm alta tolerancia
  • Fuente de alimentación impermeable IP67 con 110 y 220V CA
  • Raspberry Pi 3 y 8GB de tarjeta microSD
  • Farmduino microcontrolador con montado y probado con controladores paso a paso
  • Caja o impermeable para la electrónica
  • Montaje de la herramienta universal, cubierta y cable de 12 hilos
  • Herramienta de inyector de semilla con bomba de vacío, tubos, compartimiento de la semilla, bandeja de la semilla y agujas de bloqueo luer adaptable (3 dimensiones)
  • Boquilla de  riego con válvula solenoide, tubos y adaptadores para manguera de jardín estándar de Estados Unidos
  • Herramienta de sensor de suelo
  • Herramienta desyerba con implementos personalizables
  • cámara  USB IP67 impermeable
  • Dos toolbays de 3 ranuras

 

En este video podemos ver el equipo en funcionamiento !es impresionante!

 

Software

OpenFarm.CC fue concebido originalmente como un pequeño componente del proyecto FarmBot. A medida que se progresó, se hizo evidente que OpenFarm no tenía ninguna razón para estar atado a FarmBot, sino que podría vivir por sí solo. En septiembre de 2014, 1.605 personas respaldaron a OpenFarm en el pedal. Hoy en día, OpenFarm es una aplicación independiente, sin fines de lucro y comunidad. Puede de hecho involucrarse con OpenFarm uniendo el canal  y  contribuyendo en Github, o yendo a OpenFarm.cc y creando contenido!

Hay muchos sistemas de software que contribuyen a la funcionalidad de FarmBot. El siguiente diagrama muestra los diferentes componentes y la forma en que los datos fluyen entre ellos. Lea las breves descripciones de cada componente en las siguientes secciones para entender el sistema como un todo, y luego Sumérjase en la configuración de los componentes necesarios para su FarmBot.

La aplicación web FarmBot  ,como se pude ver en el video  anterior, permite configurar y controlar fácilmente  FarmBot desde un navegador web en su laptop, Tablet o smartphone. La aplicación cuenta con controles manuales en tiempo real y registro, un generador de secuencias para crear rutinas personalizadas para que se ejecute FarmBot y un diseñador de granjas de arrastrar y soltar para que pueda diseñar y administrar gráficamente su granja.

El broker de mensajes es una aplicación de nube que actúa como intermediario para todos los mensajes entre la aplicación web FarmBot y los dispositivos FarmBot . Maneja conexiones de socket, identificación de dispositivos y autenticación.

FarmBot Raspberry PI utiliza un sistema operativo personalizado llamado FarmBot os para mantener una conexión y sincronizar con la aplicación web a través del intermediario de mensajes. Esto permite a FarmBot descargar y ejecutar eventos programados, ser controlados en tiempo real, y cargar logs y datos de sensores. El SO se comunica con el Arduino sobre USB para enviar comandos de código G y F y también recibir datos recopilados.

FarmBot os tiene una utilidad integrada denominada Configurator que permite introducir fácilmente las credenciales de WiFi y de aplicación web desde un dispositivo habilitado para WiFi (como un ordenador portátil o un smartphone). Esto es útil para la configuración inicial con el fin de obtener su FarmBot conectado a su casa wifi.

Respecto  firmware  Farmbot para Arduino es flasheado en el microcontrolador Arduino mega 2560 de FarmBot y es responsable de operar físicamente el hardware, las herramientas, los sensores  otros componentes electrónicos de FarmBot. Recibe los códigos de G y de F del regulador del PI de la Raspberryde FarmBot vía conexión serial del USB, y después mueve los motores y Lee y escribe los pernos por consiguiente. También envía los datos recogidos de los codificadores rotatorios y el PIN Lee de nuevo a la Raspberry PI.

OpenFarm.cc es una base de datos gratuita y abierta para la agricultura y el conocimiento de jardinería. Este servicio proporciona información de cultivo y crecimiento a la aplicación web para un usuario racionalizado experimentado.

 

Hardware

FarmBot Genesis es  la plataforma de hardware de código abierto de bricolaje optimizada para la producción de alimentos a pequeña escala basada en el suelo .FarmBot Genesis , quee s la version mas económica ,  está diseñado para ser una Fundación FarmBot flexible para la experimentación, prototipado y hacking. Los factores que conducen detrás del diseño son simplicidad, manufacturabilidad, escalabilidad, y hackeabilidad.

FarmBot Genesis es una pequeña escala FarmBot principalmente construida a partir de protuberancias en V-ranura de aluminio y placas de aluminio y soportes. Génesis es conducida por cuatro motores de pasos NEMA 17 con codificadores rotativos, el microcontrolador Farmduino, y un ordenador de frambuesa PI 3. El Génesis puede variar en tamaño desde un área de plantación tan pequeña como 1m2 hasta un máximo de 4,5 m2, mientras que alberga una altura máxima de planta de aproximadamente 1m. Con el hardware y las modificaciones adicionales Anticipamos que el concepto del Génesis podría escalar a aproximadamente 50 m2 y una altura máxima de la planta de 1.5 m.

Como vemos  Farmbot no es su producto típico pues sus creadores  han pasado por grandes esfuerzos para diseñar FarmBot Genesis para ser duraderos, fácilmente ensamblados y modificados con herramientas comunes, construidos a partir de componentes en gran parte fuera de la plataforma, y fabricados con procesos y materiales fácilmente disponibles. Nada sobre FarmBot habla de obsolescencia o de propiedad.

Las pistas son uno de los componentes que realmente diferencian la tecnología de FarmBot de los tractores de ruedas tradicionales de conducción libre. Las pistas son las que permiten al sistema tener una gran precisión de una manera eficiente y sencilla. Hay muchas razones de por qué las pistas son superiores, algunas de las cuales se enumeran a continuación.

  • Las pistas proporcionan una gran precisión y permiten que el FarmBot vuelva a la misma posición repetidamente
  • Cualquier tipo de estructura de empaque de las plantas se puede crear y manejar
  • Las pistas ocupan menos área que las trayectorias para las ruedas del tractor y no compactan el suelo

El pórtico es el componente estructural que puentea las dos pistas y se mueve en la x-dirección vía un sistema de impulsión de la x-dirección. Típicamente, sirve como una guía lineal para el deslizamiento transversal y una base para el sistema de impulsión de la y-dirección que mueve el Cruz-resbale a través del pórtico en la y-dirección. También puede servir como base para el montaje de otras herramientas, electrónica, suministros y/o sensores.

La Cruz se mueve en la Y-dirección a través del pórtico. Este movimiento proporciona el segundo grado mayor de libertad para FarmBots y permite que las operaciones como la plantación se realicen en cualquier lugar del plano XY. El deslizamiento transversal se desplaza utilizando un sistema de impulsión y-dirección y funciona como la base para el montaje de la herramienta y el sistema de la impulsión de la Z-dirección.
Eje Z

El eje z se conecta a la corredera transversal y proporciona el FarmBot con movimiento de dirección z. Sirve como base para la fijación del montaje universal de la herramienta y de otras herramientas. .

Para que los FarmBots crezcan adecuadamente las plantas más altas, el pórtico, la corredera transversal, el eje Z y las herramientas deben tener una separación vertical adecuada de las plantas. Esto generalmente se puede lograr de dos maneras:

  • Usando pistas levantadas y un pórtico Low-Profile
  • Usando pistas bajas con un pórtico alto

En general, el uso de pistas bajas con un pórtico alto es el mejor diseño, especialmente para aplicaciones más grandes, ya que ahorra en costo material, es menos de una monstruosidad, bloquea menos luz del sol, y sería más fácil de mantener. Sin embargo, en el caso de un FarmBot que se está instalando en un invernadero u otra estructura, utilizando las paredes existentes para apoyar las pistas más altas puede ser una mejor solución.

 

El  Soporte universal para herramientas (universal Tool Mount o UTM)  permite a FarmBot Genesis cambiar automáticamente las herramientas para realizar diferentes operaciones. La UTM es necesaria porque no es factible tener todas las herramientas montadas en el eje z al mismo tiempo por varias razones:

  • Esto sería muy pesado y aumentaría las tensiones en todos los componentes, así como requerir un motor más grande del z-axis.
  • La mayoría de las herramientas necesitan ser la cosa “más baja” en el eje z para poder trabajar. Tener múltiples herramientas compitiendo por la posición más baja (ej: una sonda de temperatura y un inyector de semillas) no sería ideal y puede que no funcione en absoluto. El uso de mecanismos de elevación y descenso de herramientas individuales, o un mecanismo de estilo de torreta sería complejo, pesado, voluminoso y limitado en el número de herramientas que podría soportar.
  • El tamaño del eje z debe mantenerse a un mínimo para que tenga un impacto mínimo sobre las plantas, especialmente cuando no hay mucho espacio entre ellos.

La UTM es un componente de plástico que se monta en la extrusión de aluminio del eje z utilizando dos tornillos M5 y tuercas en t.Algunas de sus características:

  • 3 imanes fuertes del anillo del neodimio para sostener magnético las herramientas en el lugar vía otros imanes colocados en la misma configuración en la herramienta.
  • Pasadizos para agua, enmiendas líquidas (ej.: abono), y vacío o aire comprimido para pasar de la UTM (y el resto de FarmBot) a la herramienta.
  • 12 tornillos de resorte que hacen conexiones eléctricas con herramientas.

 

Es como vemos una de las partes cruciales del proyecto pues la que realemnte actua sobe las plantas. Precisamente en este video nos explican en que consiste esta versátil herramienta;

 

Mas información en https://farm.bot/

 

Anuncios

Huerto controlado por raspberry


Carolina Herrero nos propone un sistema de un sistema automatizado para riego  que  ademas  no precisa de conexión a Internet porque todas las medidas se  gestionan de forma interna y por tanto no precisan ningún servicio de IoT  para su  funcionamiento ( como por ejemplo Cayenne.com del que  hemos hablado numerosas ocasiones en este blog)

 

La idea principal de Carolina era construir un sistema de riego automático, controlado por diferentes tipos de sensores, de forma que el sistema tomase decisiones de modo automático  guiándose  en función de las condiciones del ambiente y la necesidad de riego que tiene la tierra según el grado de humedad  de modo que cuando las condiciones fuesen óptimas comenzase el riego(, siempre y cuando exista agua en el depósito)
Además su creadora  también quería que los datos se almacenaran de forma periódica en una base de datos local  mySQL  , y a través de una aplicación Web, con sus  credenciales poder acceder y ver un histórico gráfico de las mediciones de los sensores .
Para conseguir esto básicamente   ha utilizado:
  • Varios  Sensores
  • Una placa  Microcontroladora
  • Un Servidor local

Sensores

El sistema utiliza diferentes tipos de sensores, porque se requiere  controlar diversos valores como son :
  • Valores de la humedad de la tierra para lo que se usa un sensor conocido como YL-69, que consiste en dos picas que se encuentran enterradas en tierra de manera que controlando la resistencia de la tierra se puede conocer la humedad.Esta es una herramienta indispensable para un jardín conectado  pues por si mismo nos puede  recordar que debe regar las plantas de interior o para monitorear la humedad del suelo en su jardín . Se alimenta a: 3.3V-5V   y el modo de módulo de salida dual, salida digital, salida analógica más precisa

  • Para recoger los valores de humedad y temperatura ambiente se utiliza un  simple sensor DHT11 (si bien  un DHT22 hubiese sido  mas recomendable por su mayor precisión , aunque es cierto que su coste es algo mayor)                                                   
  • De la temperatura del suelo se encarga el DS18B20, un sensor sumergible y resistente a la humedad, que se usará para controlar la temperatura de la tierra. 
  • Por seguridad, y para evitar que las bombas funcionen en vacío, y puedan dañarse, es imprescindible controlar el nivel de agua que hay en el depósito, y estos se consigue con un sensor de nivel .Estos sensores pueden medir humedad entre el 10% -90% sin condensación con un consumo de menos de 20mA y ofreciendo una salida analógica con  un área de detección de 40mmx16mm
  •  Por último controlar si hay luz o no, para evitar el riego de noches se ha usado un sensor de luz, también conocido como resistencia LDR.

Arduino

El encargado de recoger todos los  valores  procedentes de los sensores descritos y tomar las acciones necesarias es una placa  sistema Arduino  que ha sido programado para recoger datos, actuar en función de los valores de dichos datos, y en última instancia se encarga de mandarlos a un servidor ( una Raspberry Pi) para su seguimiento estadístico  de modo que en principio si no nos interesa seguir esa traza perfectamente el proyecto quedaría únicamente con esta placa   y sus sensores .

Aquí su autora comparte  una parte del código encargado de recoger los datos, y enviarlos por el puerto serie.

//Función que se encarga de leer datos de todos los sensores
void leer_datos_sensores(){
  valor_ha = dht.readHumidity();             //Se lee la humedad en el ambiente
  valor_ta = dht.readTemperature();          //Se lee la temperatura en el ambiente
  valor_ht1 = analogRead(hum_tierra1);       //Se lee humedad en tierra en la zona1
  valor_na = analogRead(nivel_agua);         //Se mide el nivel de agua existente en el depósito
  valor_luz = analogRead(luz_ldr);           //Se lee la luz
  DS18B20.requestTemperatures();             //Prepara el sensor para la lectura
  valor_tt1 = DS18B20.getTempCByIndex(0);    //Se lee la temperatura en tierra en la zona 1        
}
//Función para enviar valores de los sensores por el puerto serie
void enviar_datos(){
  Serial.print(valor_ha);Serial.print(“,”);
  Serial.print(valor_ta);Serial.print(“,”);
  Serial.print(valor_ht1);Serial.print(“,”);
  Serial.print(valor_na);Serial.print(“,”);
  Serial.print(valor_luz);Serial.print(“,”);
  Serial.print(valor_tt1);Serial.print(“,”);
}

Servidor web y BBDD

Como servidor no podía ser de otra manera que optar  por una Raspberry PI conRaspbian, basada en Debian  y que  hace  de servidor  Base de Datos, y además también de de Servidor Web.
Como servidor web se usa el Servidor Web Apache funcionando junto con MySQL como servidor de BBDD.
Además para que Arduino y Raspberry se comuniquen entre sí, se requiere un script en Python, que se encarga de recibir los datos por el puerto Serie que Arduino está enviando de forma constante .
Básicamente este script recibe los datos de Arduino  , se conecta con la  BBDD MySql  e inserta los datos.
#!/usr/bin/python
#-*- coding: UTF-8 -*-
 
import MySQLdb
import serial
 
# Establecemos la conexión con la base de datos
bd = MySQLdb.connect(“host”,“user”,“pass”,“db” )
# Preparamos el cursor que nos va a ayudar a realizar las operaciones con la base de datos
cursor = bd.cursor()
 
#Inicia la comunicación con el puerto serie
PuertoSerie= serial.Serial(‘/dev/ttyACM0’, 9600)
#Lectura de datos
sArduino = PuertoSerie.readline()
#Separa la cadena en valores, cada valor hasta la coma es almacenado en una variable
sHumAmbiente,sTempAmbiente,sHumTierra1,sNivelAgua,sLuz,sTempTierra1=sArduino.split(“,”)
 
ha = float(sHumAmbiente)
ta = float(sTempAmbiente)
ht1 = int(sHumTierra1)
na = int(sNivelAgua)
luz = int(sLuz)
tt1 = float(sTempTierra1)
zona1 = 1
 
 
#Almacenamos los valores en tabla datos de la base de datos huerto
sql1=“INSERT INTO datos_huerto(hum_ambiente,temp_ambiente,hum_tierra,nivel_agua,luz,temp_tierra,id_zona) VALUES (%f,%f,%d,%d,%d,%f,%d)” % (ha,ta,ht1,na,luz,tt1,zona1)
 
try:
   # Ejecutamos el comando
   cursor.execute(sql1)
   bd.commit()
except:
   print “Error”
   bd.rollback()
 
# Nos desconectamos de la base de datos
bd.close()
Para se hacer esto  de forma periódica pero no constante, puede usarse  la herramienta Cron integrada en Raspbian, de manera que cada “X” minutos se ejecute el script en Python.
Para la parte de  visualización de los datos la autora opto  por o una aplicación Web sencilla, programada n Php, junto con pequeñas funciones en Javascript para controlar y validar ciertos campos. En el aspecto visual uso  el framework Bootstrap, asi como la  librería HighCharts para la creación de gráficas y así conseguir visualización de los datos muy atractiva.
arduino.png
Es muy importante que si le damos salida a internet a La Rasberry PI  nos cercioremos de que está segura. Para ello es interesante :
  • Modificar el archivo de configuración de Apache, para que ante un ataque muestre la mínima información posible sobre el servido
  • Encriptar el tráfico entre cliente y servidor mediante certificados SSL
  • Forzar para que el acceso siempre sea seguro vía peticiones del tipo  HTTPS.
 Finalmente esta es la lista de componentes utilizados para el sistema:
  • Arduino Mega 2560 Rev.3 x1
  • Raspberry Pi x1
  • Sensor de humedad de tierra YL-69 x 2
  • Sensor de temperatura y humedad ambiente DTH-11 x1
  • Sensor de luz LDR x1
  • Sensor de temperatura de tierra  SD18b20 x2
  • Sensor de nivel de agua x1
  • Placa de 4 relés 5V-220Vx1
  • Bombas de agua x2
  • Protoboard x1
  • Resistencias de pull-up de diferentes valoresx 12
  • Cableado y conectores –
  • Leds de diferentes colores x15
  • Bandeja de plástico x1
  • Piezas de policarbonato x2
  • Recipientes para depósito de agua y electrónica x2
  • Tarjeta SD  para Raspberry PI x1
  • Tubos de goteo x2
  • Plantasx 6
  • Fuente de alimentación 220V x1

Le damos nuestra mas sincera enhorabuena a Laura por su sistema que animamos a que siga perfeccionando así como compartiendo con la comunidad todos sus progresos

Controle su Roomba con Arduino y Android


 

iRobot Roomba Create2 es una a  plataforma grande y muy asequible para el desarrollo de la robótica, costando alrededor de US$ 200 permitiendo  una variedad de métodos de programación. Como  comienzo mjrovi usó  un Arduino y una aplicación Android para mover el robot  por puerto serie  consiguiendo asi controlar  sus motores, LEDS y sonido.

Como uno de los ganadores de 2016 del concurso de robótica   en Instructables, mjrovi recibió como premio un iRobot Roomba Create2.

 

 

La Roomba es un robot de impulsión diferenciada, con 2 ruedas motrices y una rueda  central  guía. Su velocidad va hasta 500 mm/s y puede ser mandado a ir hacia arriba o hacia atrás.
Para señalización, contamos con cuatro 7 segmentos display y 5 LEDs :

  • Limpiar
  • Punto
  • Muelle
  • ADVERTENCIA/Check
  • Suciedad/escombros

Como sensores internos, tenemos entre otros:

  • Detector de acantilado (4 en el frente)
  • Detectores Bump (frente 2)
  • Codificadores de rueda

Para la programación, el documento: iRobot® Create® 2 abierto interfaz (OI) debe ser utilizado.El Roomba puede ser programado en 3 modos:

  1. Modo pasivo:Al enviar el comando de Start o cualquiera de los comandos de modo de limpieza (por ejemplo, punto limpio, muelle buscar), la OI entra en modo pasivo. Cuando la OI está en modo pasivo, puede solicitar y recibir datos de los sensores usando cualquiera de los comandos del sensor, pero no puede cambiar los parámetros de comando actuales para los actuadores (motores, altavoces, luces, controladores de lado de baja, salidas digitales) a otra cosa.
  2. Modo seguro :Le da un control completo de Roomba, con excepción de las siguientes condiciones relacionadas con la seguridad:
    Cargador conectado y alimentado:detección de una caída de rueda (en cualquier rueda),detección de un acantilado mientras se mueve hacia adelante (o hacia atrás con un pequeño radio de torneado, menos de un radio de robot) o si ocurre una de las condiciones relacionadas con la seguridad mientras que el OI es en modo seguro, Roomba detiene todos los motores y vuelve al modo pasivo.
  3. Modo completo:Le da un control completo sobre Roomba, todos de sus actuadores y todas las condiciones relacionadas con la seguridad que están restringidas cuando la OI en modo seguro, como el modo completo se apaga el acantilado, caída de rueda y características de seguridad cargador interno.

Comunicaciones

Para  programar la Romba  la lista de  materiales  usada es la siguiente:

  • iRobot Create2
  • Arduino UNO
  • Módulo Bluetooth HC-06
  • Pulsador

Para la comunicación entre la Roomba y Arduino, se utilizará el puerto Serial. Por defecto, Roomba comunica a 115.200 baudios, pero para comunicarse con Arduino, se cambiará a 19.200.

Hay 2 formas de establecer la tasa de baudios de Roomba:

  1. Mientras que apagar Roomba, continúan mantenga pulsado el botón de encendido o limpiar después de que la luz se ha apagado. Después de unos 10 segundos, Roomba juega una melodía descendente de las echadas. Roomba se comunicará a 19.200 baudios hasta que el procesador pierde energía de la batería o la tasa de baudios se modifica explícitamente a través de la OI.
  2. Utilizar el pin de cambio de tasa de baudios (pin 5 del conector mini-DIN) para cambiar la velocidad en baudios de Roomba. Después de encender la Roomba, esperar 2 segundos y luego pulso el cambio de la tasa de baudios baja tres veces. Cada impulso debe durar entre 50 y 500 milisegundos. Roomba se comunicará a 19200 baudios hasta que el procesador pierde energía de la batería o la tasa de baudios se modifica explícitamente a través de la OI.

 

El diagrama de arriba muestra cómo la Arduino debe conectarse al conector mini-DIN de Roomba

 

 

Lo primero creo que debe hacerse cuando un Roomba de programación es “Despertar” el robot y  Definir el modo (segura o completa)

Nosotros podemos  hacer  un “wake-up”, enviar un poco de pulso al pin mini-DIN 5 (detección de dispositivo de entrada) como se muestra en la siguiente función:
void wakeUp (void)
{
setWarningLED(ON);
digitalWrite(ddPin, HIGH);
delay(100);
digitalWrite(ddPin, LOW);
delay(500);
digitalWrite(ddPin, HIGH);
delay(2000);
}

Para empezar a Roomba deberán enviarse 2 códigos de siempre: «START» [128] y el modo, en nuestro caso “Modo seguro” [131]. Si usted quiere un “modo completo”, debe enviarse en su lugar el código [132].
void startSafe()
{
Roomba.write(128); //Start
Roomba.write(131); //Safe mode
delay(1000);
}

 

Como se describe en la introducción, el Roomba tiene 5 LEDs:

  • Energía/limpiar (bicolor rojo/verde e intensidad controladas)
  • Punto (verde, intensidad fija)
  • Muelle (verde, intensidad fija)
  • ADVERTENCIA/Check (naranja, intensidad fija)
  • Suciedad/escombros (azul, fija la intensidad)

 

Control de leds

Todos los LEDs pueden ser ordenados mediante código [139]
Para controlar el LED de encendido, debe enviar dos bytes de datos a Roomba: “color” y la “intensidad”.
Color:

  • Verde = 0
  • Naranja = 128
  • rojo = 255

Intensidad:

  • Bajo = 0
  • Max = 255

La función setPowerLED (colores bytes, setIntensity bytes) lo hace:

void setPowerLED(byte setColor, byte setIntensity)
{
color = setColor;
intensity = setIntensity;
Roomba.write(139);
Roomba.write((byte)0x00);
Roomba.write((byte)color);
Roomba.write((byte)intensity);
}

Por ejemplo, para encender el LED de POWER de color naranja en la mitad de su intensidad, usted puede llamar a la función como bramido:setPowerLED (128, 128);

Encender los 4 LEDs restantes, deberán utilizarse las siguientes funciones:
setDebrisLED(ON);
setDockLED(ON);
setSpotLED(ON);
setWarningLED(ON);

Todas las funciones anteriores tiene un código similar a este:
void setDebrisLED(bool enable)
{
debrisLED = enable;
Roomba.write(139);
Roomba.write((debrisLED ? 1 : 0) + (spotLED ? 2 : 0) + (dockLED ? 4 : 0) + (warningLED ? 8 : 0));
Roomba.write((byte)color);
Roomba.write((byte)intensity);
}

Básicamente, la diferencia será la línea: debrisLED = habilitar;  debe modificarse permitiendo a cada uno de los otros LEDs (spotLED, dockLED, warningLED).

 

Envío de mensajes

Roomba tiene cuatro 4 displays de 7 segmentos que puede utilizar para enviar mensajes de dos maneras::
[163] código: Dígitos LED crudo (numérico)
[164] código: Dígitos LED de ASCII (aproximación de letras y códigos especiales)
Para mostrar números  debe enviar el código [163], siguiendo las 4 digitas a mostrar. La función: setDigitLEDs (bytes digit1 digit2 bytes, digit3 bytes, digit4 bytes) lo hace para usted:

void setDigitLEDs(byte digit1, byte digit2, byte digit3, byte digit4)
{
Roomba.write(163);
Roomba.write(digit1);
Roomba.write(digit2);
Roomba.write(digit3);
Roomba.write(digit4);
}

Por ejemplo, para mostrar “1, 2, 3, 4”, debe llamar a la función: setDigitLEDs (1, 2, 3, 4);

Con el código [164], es posible enviar aproximación de ASCII.

La función setDigitLEDFromASCII (dígitos de byte, char letra) hace esto para nosotros:
void setDigitLEDFromASCII(byte digit, char letter)
{
switch (digit){
case 1:
digit1 = letter;
break;
case 2:
digit2 = letter;
break;
case 3:
digit3 = letter;
break;
case 4:
digit4 = letter;
break;
}
Roomba.write(164);
Roomba.write(digit1);
Roomba.write(digit2);
Roomba.write(digit3);
Roomba.write(digit4);
}

Para simplificar, crear una nueva función para enviar los 4 dígitos al mismo tiempo:
void writeLEDs (char a, char b, char c, char d)
{
setDigitLEDFromASCII(1, a);
setDigitLEDFromASCII(2, b);
setDigitLEDFromASCII(3, c);
setDigitLEDFromASCII(4, d);
}

Por ejemplo, para mostrar “STOP”, usted debe llamar a la función: writeLEDs (‘s’, ‘ t ‘, ‘ o ‘, ‘p’);

Mover la  Roomba

Para la movilidad, Roomba tiene 2 motores independientes que pueden programarse para ejecutar 500mm/s. Hay varios comandos que pueden utilizarse para controlar el robot. Los principales son:

  • Código [137]: Unidad == > debe enviar +-velocidad en mm/s y +-radio en mm
  • Codigo [145] de código: Impulsión directa == > debe enviar izquierda velocidad en mm/s (+ para adelante y para atrás)
  • Código [146]: Unidad PWM == > debe enviar +-datos PWM para la izquierda y derecha las ruedas

 

A continuación el código para estas 3 opciones:

void drive(int velocity, int radius)
{
clamp(velocity, -500, 500); //def max and min velocity in mm/s
clamp(radius, -2000, 2000); //def max and min radius in mm

Roomba.write(137);
Roomba.write(velocity >> 8);
Roomba.write(velocity);
Roomba.write(radius >> 8);
Roomba.write(radius);
}

//—————————————————————

void driveWheels(int right, int left)
{
clamp(right, -500, 500);
clamp(left, -500, 500);

Roomba.write(145);
Roomba.write(right >> 8);
Roomba.write(right);
Roomba.write(left >> 8);
Roomba.write(left);
}

//—————————————————————
void driveWheelsPWM(int rightPWM, int leftPWM)
{
clamp(rightPWM, -255, 255);
clamp(leftPWM, -255, 255);

Roomba.write(146);
Roomba.write(rightPWM >> 8);
Roomba.write(rightPWM);
Roomba.write(leftPWM >> 8);
Roomba.write(leftPWM);
}

Tenga en cuenta que la función de “fijar” define los valores máximos y mínimos que se permitieron la entrada. Esta función se define en el archivo rombaDefines.h:

#define abrazadera (valor, min, max) (valor < min? min: valor > max? max: valor)
Utilizando el código anterior, se pueden crear funciones más simples para Roomba alrededor de:
/—————————————————————
void turnCW(unsigned short velocity, unsigned short degrees)
{
drive(velocity, -1);
clamp(velocity, 0, 500);
delay(6600);
drive(0,0);
}

//—————————————————————
void turnCCW(unsigned short velocity, unsigned short degrees)
{
drive(velocity, 1);
clamp(velocity, 0, 500);
delay(6600);
drive(0,0);
}

//—————————————————————
void driveStop(void)
{
drive(0,0);
}

//—————————————————————
void driveLeft(int left)
{
driveWheels(left, 0);
}

//—————————————————————
void driveRight(int right)
{
driveWheels(0, right);
}

Tenga en cuenta que para girar en ángulo, debe calcularse el argumento de “retraso” específicamente para una velocidad dada

A continuación algunos ejemplos que pueden utilizar para probar los motores:

turnCW (40, 180); girar 180 grados hacia la derecha y parada
driveWheels (20, -20); vuelta
driveLeft(20); girar a la izquierda

Para las pruebas de los motores, es bueno añadir un pulsador externo (en mi caso conectado al Arduino pin 12), para que puedan descargar el código de Arduino, a partir de la Roomba, pero parando la ejecución hasta que se pulsa la tecla. Generalmente, para los motores de prueba lo puedes hacer en la parte de configuración del código.

Como ejemplo, consulte el código de Arduino simple abajo (nota que el código usa funciones y definiciones desarrollaron antes):

#include “roombaDefines.h”
#include

// Roomba Create2 connection
int rxPin=10;
int txPin=11;
SoftwareSerial Roomba(rxPin,txPin);

//———————————————
void setup()
{
Roomba.begin(19200);

pinMode(ddPin, OUTPUT);
pinMode(buttonPin, INPUT_PULLUP); // connected to Arduino pin 12 and used for “starting”

delay(2000);

wakeUp (); // Wake-up Roomba
startSafe(); // Start Roomba in Safe Mode

while (digitalRead(buttonPin)) { } // wait button to be pressed to continous run code

turnCW (40, 180); //test Roomba spin clock-wise 180 degrees and stop
}

//———————————————
void loop()
{

}

 

Controlar la Roomba a través de Bluetooth

Para controlar  Roomba de modo inalambrico   vamos a instalar un módulo Bluetooth (HC-06) a nuestro Arduino. El diagrama de arriba muestra cómo hacerlo. Suele ser el HC-06 settle up de fábrica con una velocidad de 9.600. Es importante cambiarlo a 19.200 para ser compatible con la velocidad de la comunicación de Arduino-Roomba. Usted puede hacer que el envío un comando AT para el módulo (AT + BAUD5 donde “5” es el código de 19.200).

Para controlar la Roomba, utilizaremos una aplicación genérica que fue desarrollada por jrovai   para el control de robots móviles, con el MIT AppInventor 2: “MJRoBot BT Remote Control”. La aplicación puede descargarse gratuitamente de la tienda de Google a través del enlace: aplicación: MJRoBot BT Remote Control.

La aplicación tiene una interfaz sencilla, lo que le permite enviar comandos al módulo de BT en ambos, modo de texto o directamente a través de botones preprogramados (cada vez que se pulsa un botón, un carácter se envía):

  • w: hacia adeñante
  • S: hacia atras
  • d: derecho
  • a: izquierda
  • f: parada
  • p: ON / OFF (no usado en esta primera parte)
  • m: manual / automático (se utiliza para reiniciar Roomba si un obstáculo como un acantilado se encuentra en modo seguro)
  • +: Velocidad +
  • -: Velocidad –

También puede enviar otros comandos como texto si es necesario. También hay una ventana de texto para los mensajes recibidos desde el módulo de BT. Esta característica es muy importante durante la fase de prueba, puede ser utilizado en la misma forma que el “Serial Monitor”.

El loop() parte del código será “escuchando” el dispositivo bluetooth y dependiendo del comando recibido, tomar una acción:

void loop()
{
checkBTcmd(); // verify if a comand is received from BT remote control
manualCmd ();
}
La función checkBTcmd() se muestra a continuación:

void checkBTcmd() // verify if a command is received from BT remote control
{
if (BT1.available())
{
command = BT1.read();
BT1.flush();
}
}
Una vez que se recibe un comando, la función manualCmd() tomará la acción apropiada:
void manualCmd()
{
switch (command)
{

case ‘m’:
startSafe();
Serial.print(“Roomba in Safe mode”);
BT1.print(“Roomba BT Ctrl OK – Safe mode”);
BT1.println(‘\n’);
command = ‘f’;
playSound (3);
break;

case ‘f’:
driveStop(); //turn off both motors
writeLEDs (‘s’, ‘t’, ‘o’, ‘p’);
state = command;
break;

case ‘w’:
drive (motorSpeed, 0);
writeLEDs (‘ ‘, ‘g’, ‘o’, ‘ ‘);
state = command;
break;

case ‘d’:
driveRight(motorSpeed);
writeLEDs (‘r’, ‘i’, ‘g’, ‘h’);
break;

case ‘a’:
driveLeft(motorSpeed);
writeLEDs (‘l’, ‘e’, ‘f’, ‘t’);
break;

case ‘s’:
drive (-motorSpeed, 0);
writeLEDs (‘b’, ‘a’, ‘c’, ‘k’);
state = command;
break;

case ‘+’:
if (state == ‘w’)
{
motorSpeed = motorSpeed + 10;
if (motorSpeed > MAX_SPEED)
{
motorSpeed = MAX_SPEED;
}
command = ‘w’;
} else {command = state;}
break;

case ‘-‘:

if (state == ‘w’)
{
motorSpeed = motorSpeed – 10;
}
if (motorSpeed < MIN_SPEED )

{ motorSpeed = MIN_SPEED; }

Serial.println(motorSpeed); command = state; break; } }

 

 

 

El código de Arduino completo utilizado en documentos aquí relacionados se puede encontrar en GITHUB en https://github.com/Mjrovai/Roomba_BT_Ctrl

Varias de las funciones que   el autor  ha creado en su  programa se basaron en la biblioteca de crear 2 desarrollada por Dom Amato. Puede descargar la librería completa en‎: https://github.com/brinnLabs/Create2.

Software para CNC


Aunque  vivimos sin duda  una gran revolución  con la impresión 3d, de forma  silenciosa ,pero firme ,  también estamos viviendo  un considerable avance en el mundo de las maquinas tradicionales de todo tipo (fresadoras, piro-grabadoras, dibujo, corte, láser, etc. )  , eso si  ,controladas no por maquinas especificas diseñadas para su control como antaño , sino  simplemente por cualquier  ordenador y  por potentes  software de control que sin duda permite  obtener resultados completamente profesionales.

Estas maquinas conocidas como router CNC  o simplemente  CNC  en efecto son adecuadas para tallar madera, acrílico o metal blando, madera nativa, PCB CCL, PVC y un largo etcétera  lo cual permite infinidad   de aplicaciones para los profesionales  y también para los aficionados  al bricolaje  y  a la electrónica  dado que su precio  así como también  su tamaño  han hecho que estén accesibles a  casi todos los bolsillos .

Un  router CNC  se puede simplemente comprar  ya montado , en kit  con  todos los componetes ya preparados para montarlos por uno mismo  o fabricarlo  por uno mismo (en la web de OpenBuilds han publicado unos interesantes vídeos sobre una maquina llamada OX  y todo el proceso ), pero en todo caso   su coste suele ser una fracción de lo que cuesta una impresora 3d   en parte porque   normalmente se va a mover sobre solo dos ejes y no requiere  otras partes   que añaden coste y complejidad al  equipo ( un eje z largo , el extrusor o la cama caliente)

 

Una de las utilidades que ya comentamos en un post anterior es la  posibilidad de realizar placas de circuito impreso (PCB),  pero hay muchísimas opciones  como cortar madera, realizar grabados , escultura   y un largo etcétera

 

 

Para  fabricar  placas de circuito   impreso  con  una maquina  CNC   comentamos en  este post  , el   potente  programa    OPenCNCPilot que  nos permite obtener resultado muy profesionales  precisos y limpios  sin usar peligrosos líquidos  peligrosos, pero para otros  usos , sin  duda   bCNC   es  otro programa muy versátil   que  permite controlar  CNC que funcionen a través de arduino y que usen el firmware grbl.

bCNC

Este programa en un gestor GRBL es un    CNC command sender, autoleveler y editor de g-code

Cuenta con un  emisor avanzado de códigos g para GRBL . Este programa es  multiplataforma (Windows, Linux, Mac) escrito en python. El remitente es robusto y rápido capaz de trabajar muy bien con hardware antiguo o lento como Rasperry PI (como fue validado por el mainter de GRBL en pruebas pesadas)  y como vamos  a ver tiene infinidad de opciones.

Como no podía  ser  de otra manera  también permite realizar placas de circuito impreso:

 

bCNC screenshot

Instalación

 

El sw  se puede descargar directamente  desde https://github.com/vlachoudis/bCNC

Necesitará los siguientes paquetes para ejecutar bCNC

  • tkinter el conjunto de herramientas gráficas para python Dependiendo de su python / OS ya puede estar instalado o bajo los nombres tkinter, python-tkinter, python-tk
  • pyserial o bajo el nombre python-serial, python-pyserial
  • python-image-tk: las bibliotecas PIL para el mapa de altura de autolevel  (opcional)
  • python-opencv: para la transmisión por webcam en el colgante web(opcional)

Expanda el directorio o descárguelo desde github y ejecute el comando bCNC

Puede modificar la mayoría de los parámetros desde la página “Herramientas -> Máquina”. Solo los cambios / diferencias del archivo de configuración predeterminado se guardarán en su directorio de inicio $ {HOME} /. BCNC o ~ / .bCNC

La configuración predeterminada se almacena en bCNC.ini en el directorio de instalación. (POR FAVOR NO CAMBIE ESTE)

 

Menú editor Gcode

Entre sus características principales esta el editor de gcode, que nos permite hacer modificaciones sin tener que volver al software CAM.

Entre las opciones del menú de edición podemos nombrar las funciones de copiar y pegar lo que nos permite duplicar una porción del código, opciones de selección de bloques de código lo que nos facilita la edición.

El botón insertar nos permite, agregar lineas de código dentro de un bloque, clonar nos permite duplicar bloques, ademas tenemos botones para eliminar bloques, habilitar o deshabilitar bloques para que estos no se ejecuten pero sin borrarlos.

Los botones de Subir y Bajar , cambian el orden en el que se ejecuta un bloque de código,esto nos permite ordenar el gcode a nuestro gusto, y también tenemos una herramienta para invertir el orden de los bloques seleccionados.La herramienta mover nos permite cambiar la posición de los bloques simplemente seleccionando un bloque y arrastrarlo a la posición deseada. Necesaria para mover bloques que fueron clonados o copiados.El botón de establecer origen nos permite mover todo el trabajo, a la posición donde hagamos clic con el ratón.

Adicionalmente tenemos herramientas de rotar y reflejar y botones que nos permiten invertir el la dirección del corte.

Menú Herramientas

En el menú herramientas o tools tenemos la posibilidad de configurar los materiales o sustratos que usamos y guardarlos en una base de materiales y lo mismo podemos hacer con las herramientas de corte. Esto nos sirve en caso de que generemos las trayectorias directamente desde bCNC.

Ya que en bCNC es posible importar directamente vectores DXF o SVG y hasta tiene soporte para STL.

Dentro de las opciones cam, tenemos herramientas para hacer cortes, perfilados y taladrados.También podemos ahuecar una superficie, generar pestañas y aplanar superficies.

Y   aqui   vienen realmente  las posibilidades de este programa :

E

  • BOWL   Bowl, sirve para generar una concavidad o como su propio nombre loo describe un bowl.
  • BOX :Box es una herramienta para generar cajas con encastres como las que se encuentran en la web pero esta integrada con el programa , ademas las trayectorias generadas con para corte con fresa o con router cnc ya que compensa la circunferencia de la herramienta.Para poder generar una caja lo único que tenemos que hacer es darle los valores de altura, ancho, y profundidad ( X, Y, Z), ademas de la cantidad de encastres que queremos en cada cara y seleccionar el tipo de corte perfilado (Por fuera) , o corte (por sobre).Y por ultimo presionamos el botón ejecutar y se nos genera el g-code de nuestra caja con encastres.
  • Driller:El Driller nos permite generar trayectorias de taladrado, a lo largo de un vector, como se puede ver en la imagen hemos creado una seria de taladrados a lo largo de un vector con forma de circulo.
  • Aplanado (Flatten):Esta herramienta es muy simple nos permite generar una trayectoria de aplanado, con nuestro router cnc, solo tenemos que darle las coordenadas de los ejes X e Y para el inicio, y luego el alto, el ancho y la profundidad final del aplanado.Luego damos en el botón ejecutar y se nos genera el código G correspondiente.
  • Gear – Generador de Engranajes:Esta opción nos permite generar engranajes, los parámetros que debemos pasarle con el numero de dientes el angulo del diente y el diámetro.
  • Heightmap – Mapas de altura:Los mapas de altura son imágenes en escala de grises, que el programa interpreta como ALTOS los colores obscuros y como bajos los colores claros.Bcnc tiene la función heightmap que lo que hace es generar una trayectoria de corte a distintas profundidades generando así un relieve o corte en 3d.Pero en vez de usar un modelo 3d se pueden usar imágenes o fotografías pero para obtener buenos resultados se requiere que la imagen tenga las condiciones adecuadas de luz y sombras.
  • Pyrograph – Pirograbado con router cnc: El pirograbado es similar al grabado con láser, pero en vez de utilizar un haz de luz láser para el grabado, (lo cual es bastante peligroso si no se toman las medidas  de protección correspondientes  ) , utilizando en su lugar  una punta caliente o pirograbador. Bcnc cuenta con una herramienta para generar gcode para pirograbado, este gcode lo que hace es recorrer la imagen variando la velocidad de avance o feed rate para así lograr mayor o menor grado de quemado sobre la madera o material a grabar, sin cambiar la altura del eje Z.Para hacer una trayectoria de pirograbado necesitamos una imagen de preferencia en escala de grises, y luego pasar los parámetros.Diámetro de la punta, altura de trabajo en Z, tamaño máximo, velocidad mínima, velocidad máxima, dirección del recorrido, y la imagen a grabar.Luego damos click en execute y se nos genera el gcode correspondiente, si ven la imagen anterior parece que el gcode solo fuera un recorrido recto, pero eso es por que solo varia la velocidad de avance de la herramienta no la altura en Z.
  • Spirografo – Generador de patrones espirografico.:Interesante si le gustan los espirografos….
  • Text Generator – Generador de Texto para CNC o Imagen Texto:Interesante herramienta para generar texto para cortar letras con tu cnc o Láser.Solo tendremos que introducir el texto deseado elegir el archivo del tipo de fuente que queramos, establecer parámetros como anchura de los caracteres y listo.Pero esta herramienta tiene una función extra que es la capacidad de generar un texto a partir de una imagen.

 Menu maquina o (machine)

En este menú tendremos la posibilidad de configurar las características de nuestro router cnc o Láser. Primero configuramos las unidades, por defecto vienen configurado para milímetros así que a menos que queramos trabajar en pulgadas no deberemos tildar la opción UNITS (INCHES).

La siguiente opción es LaserCutter esta opción solo se deberá activar si en vez de un router cnc tenemos un cortador o grabador Láser. Lo que hace esta opción es activar el uso del los comandos gcode para control de un modulo láser por ttl. Esta opción esta disponible para la versión del firmware GRBL V1.1

En los siguientes nueve parámetros podremos configurar las aceleraciones, velocidades, y recorrido máximo para cada eje de nuestro router o maquina cnc.La opción decimal digits nos permite configurar cuentos decimales le enviara el programa al firmware en los movimientos de los ejes.Luego tenemos resolución de arcos, por defecto en 0,1.

Startup es el gcode de inicio que se envía a la maquina por defecto G90 ( distancias absolutas) si queremos movimientos incrementales tenemos que poner ( G91).Spindle RPM maximas y minimas.

Y por ultimo el header gcode y footer gcode, estos son los gcodes de inicio y fin nos sirve para por ejemplo hacer que se encienda nuestro husillo y que se ajuste a las rpm deseadas antes de empezar y el de fin nos sirve para mover los ejes a una posición deseada luego de finalizado el corte o trabajo.

Control

En esta pestaña es donde vamos a pasar ms tiempo ya que aquí están todas las herramientas de control mas comunes de cualquier software para cnc.

Primero tenemos los botones para crear, abrir y guardar gcode o cualquier archivo con el que vallamos a trabajar. Ademas tenemos el botón de HOME, que lo que hace es enviar el comando G28.

Lo que hace es mover los ejes en busca de los finales de carrera, luego el botón de unlock que nos permite desbloquear nuestra maquina ( recordar que GRBL firmware tiene una opción para bloquear los movimientos de los ejes. ), y por ultimo el reset que reinicia el firmware.

Ahora le toca el turno a una de las funciones que yo mas valoro de este software, y aunque es muy simple también resulta muy util.

Scan

SCAN este botón nos permite hacer un recorrido por los margenes de nuestro vector, gcode o diseño. De modo que al presionarlo los ejes X e Y se moverán recorriendo los limites del espacio que ocupa el modelo.   Esta función es muy útil cuando deseamos saber si lo que vamos a cortar, entra dentro del sustrato o de la pieza a cortar. También podremos determinar si la posición a cortar sera la que necesitamos. Hay que tener la precaución de levantar el eje Z a una posición en la que no tenga riesgos de colisionar con la pieza o algún otro obstáculo.

Debajo de scan tenemos otros botones que son 2, 3, 4, 5 y 6, estos botones son programables o personalizables aquí podemos escribir comandos.

Por ultimo los botones de control de gcode:  Start inicia el corte o trabajo, pause nos permite pausar el trabajo y stop detienen el proceso que se este ejecutando. Luego tenemos el visualizador del estado de la maquina, donde veremos el estado de la conexión con el cnc, las posiciones de trabajo y las posiciones de la maquina.

Debajo de la posición de caga eje tenemos 3 botones con la inscripción X=0, Y=0 y Z=0. Estos nos permiten establecer el cero de cada eje para la posición de trabajo.

Ahora vemos la sección workspaces, donde tenemos 6 espacios de trabajo (G54, G55, G56, G57, G58 y G59)  donde podremos personalizar distintas configuraciones para aplicarlas al trabajo que estemos por realizar. Aquí podremos definir valores como el el modo de desplazamiento (absoluto o incremental), las unidades de trabajo (mm o Pulgadas) plano de trabajo (XY, YZ o ZX),

 

Control de los ejes

Aquí tendremos acceso a los botones correspondientes al control manual de los ejes de nuestro cnc donde ademas podremos seleccionar la cantidad de unidades de desplazamiento.También vemos que podremos controlar el feed rate, al vuelo mientras estamos realizando un corte o trabajo con nuestro cnc.

Y de el mismo modo podremos acceder al control de rpm de nuestro husillo.

Visor de trabajo

A la derecha tenemos el visor del gcode o archivo que estemos por ejecutar, aquí podremos seleccionar entre distintos planos de vista, ( XY, XZ, YZ, ISO1, 2, 3).Ademas tenemos los controles de zoom in y zoom out y mostrar todo.Ahora en la sección tool tenemos la herramienta de selección que lo que nos permite es seleccionar partes de nuestro gcode para realizar acciones como eliminar o desactivarlas entre otras.b También tenemos la herramienta mover visor que lo que hace es mover la posición del modelo en el visor.

Y ahora vemos las funciones MoveGantry y Set Work Position,

  • Move gantry nos permite mover con 2 click el cabezal a la posiciones de nuestro gcode que le indiquemos en el visor.Asi por ejemplo si yo hago click en move Gantry y luego hago click en el centro de mi gcode formado por 2 círculos concéntricos, los ejes X e Y se moverán hasta alcanzar la posición señalada con el puntero.Esto es muy útil por ejemplo para saber donde estará el centro de mi gcode en el material o pieza a cortar, de modo que con esta herramienta podremos movernos con 2 clics a cualquier posición de nuestro plano de visión. Tener en cuenta que los ejes se moverán de a cuerdo al plano de visión, de modo que si estamos en el plano X-Z los ejes que se moverán serán X y Z.
  •  SetWorkPosition;Esta botón también es uno de los mas usados en Bcnc ya que nos permite establecer la posición de trabajo de nuestros ejes con solo hacer 2 clicks.Como en el ejemplo anterior, con set work position podremos con solo 2 clicks decirle al programa que en la posición donde hicimos click es donde están posicionados nuestros ejes X e Y en este momento. Otro ejemplo de uso seria, mover nuestros ejes a una posición determinada donde queremos que quede el centro de nuestro trabajo, y luego damos click en SetWorkPosition y luego hacemos click en el centro de nuestro gcode en el visor.

Ademas en la sección Draw tenemos botones para activar o desactivar la visualización de las diferentes partes de nuestro trabajo. Primero tenemos el botón Display Axis, que lo que hace es activar o desactivar la visualización de los ejes del visor.Después tenemos Grid Lines que activa o desactiva la visualización de la cuadricula.

Display Margins lo que hace es activar o desactivar la visualización de los margenes.

Por ultimo activar o desactivar la visualización de los movimientos G1, G2 y G3 o los movimientos de corte y también tenemos un botón para desactivar los movimientos G0 o los movimientos Rápidos.

 

 

Terminal

Ademas bcnc nos provee de un terminal desde el que podremos enviar comando manuales a nuestro cnc, en grbl es muy útil por ejemplo para hacer la configuración de los valores de la eeprom. Y para dar por finalizado este recorrido por las características y herramientas de bcnc, nos vamos a la pestaña files: Aquí vamos a encontrar la configuración de la conexión con nuestra maquina, donde podremos seleccionar el puerto serie donde tenemos conectado nuestro arduino, y la velocidad de comunicación o baudrate.

 

 

Hemos recorrido la mayoría de las funciones disponibles en este estupendo  software Libre para control de una  CNC llamado Bcnc.

Programar Arduino con Eclipse


Arduino es una plataforma de prototipado electrónica de código abierto basada en software y hardware flexible y fáciles de usar. Está destinado a artistas, diseñadores, aficionados y cualquiera interesado en la creación de objetos interactivos o entornos.
En realidad el Arduino es un montón de cosas. Dado un determinado contexto, puede significar cualquiera de las siguientes…

  • Arduino , la plataforma de hardware (el «Consejo»)
  • Arduino – la biblioteca de abstracción sobre el WinAVR. WinAVR es la cadena de herramientas GNU (compilador + C Runtime library etc.) para el Microcontrolador AVR utilizado en las placas de Arduino (el “software”)
  • Arduino – “El IDE” (estamos utilizando Arduino 19)

Para empezar con Arduino antes de nada se  necesita familiarizarse con la plataforma Arduino y jugar con el IDE de Arduino que es libremente descargable desde la Web de Arduino.

Si es un  programador experto , pronto se dará cuenta   que necesita  un más potente conjunto de herramientas como puede ser  la combinación de WinAVR , biblioteca Arduino + Eclipse y esto es lo que vamos a ver en este post.

 

leds arduino

Instalación  IDE

Sucintamente  los pasos para  programar Arduino con el Eclipse son los siguientes:.

  1. Descargar Eclipse (sobre 90 MBs). Descomprimir en C:\Misc\Eclipse
  2. Descargar el IDE de Arduino. Descomprimir en C:\Misc\arduino-0019
  3. Descargar la última versión de WinAVR. Descomprimir en C:\Misc\WinAVR
  4. Descargar el Plug-in de Eclipse de AVR e instalarlo (siga las instrucciones en su página web)

Primeros pasos con Eclipse

  1. Iniciar Eclipse
  2. Cerrar la página de bienvenida haga clic en la Cruz en la ficha para revelar el ambiente de trabajo real…
  3. Comenzar un nuevo proyecto haciendo clic en “archivo -> Nuevo -> proyecto de C++“. Elegir el tipo de proyecto “AVR Cross Target biblioteca estática” y establezca el nombre del proyecto Arduino. Ahora vamos a compilar los archivos fuente de Arduino en una biblioteca estática para su uso posterior. Finalmente haga clic en finalizar.
  4. Utilice el explorador de Windows para ir a C:\Misc\arduino-0019\hardware\arduino\cores\arduino, seleccionar todos los archivos de código y arrastrar sobre el proyecto de Arduino ya abierto en Eclipse( Nota :sólo incluyen archivos con extensiones .c, .cpp y .h …)
  5. A continuación, haga clic en aceptar en el siguiente cuadro de diálogo (aceptar la opción de copia por defecto)…
  6. Ahora construya el proyecto haciendo clic derecho sobre él y eligiendo “Crear” en el menú contextual. !puede  que tengamos mas de 10 errores! Pero no se preocupe, a arreglarlos en el momento. Haga clic derecho sobre el proyecto y elija “Propiedades” e ir a la opcion “c/c ++ Build -> Configuración -> AVR compilador” . Haga clic en el icono “+” (después de seleccionar la opción “Directorios”).
  7. Haga clic en el botón “Área de trabajo...” y añadir el directorio del proyecto ${workspace_loc :/ ${Nombre_proyecto}} como un directorio de inclusión una vez para el “compilador AVR” y el “AVR C++ Compiler”
  8. Haga clic derecho sobre el proyecto y elija “Propiedades“, luego ir a “AVR -> Target Hardware” y luego establecer la opción de tipo de MCU en el microprocesador en la placa Arduino junto con la frecuencia del cristal suministrado con él. Por  ejemplo para un arduino antiguo  que lleve el ATmega328P  el valor es de  16000000 respectivamente. A continuación, haga clic en ok.
  9. Ahora construya su proyecto de nuevo  de modo qeu  la construcción debería tener éxito esta vez.(Aunque es posible que vea un montón de advertencias que, simplemente puede ignorarlos por ahora).

Ejemplo

  1. Es hora de que el equivalente a “Hola mundo” el mundo de sistemas embebidos. Ir a “archivo -> Nuevo -> proyecto de C++” como antes pero ahora seleccione “AVR Cross Target solicitud” como el tipo de proyecto y establezca el nombre del proyecto a “social
  2. Haga clic derecho sobre el proyecto social y elegir “New -> File”, el nombre del archivo a Main.cpp y haga clic en finalizar.
  3. Ahora, agregue el código siguiente de C++ a Main.cpp:
    #include "WProgram.h" //Include arduino headers
    
    ///CONSTANTS///
    //The onboard test LED is connected to pin number 13
    const int ledPin = 13;
    const int interval = 1000; //Milliseconds
    
    ///MAIN///
    int main()
    {
        //Initialize the Arduino library.
        //Not doing so will prevent the delay function
        //from working. Calling this functions is a must
        //for all arduino projects.
        init();
    
        //Initialize the serial port. This will be used
        //to send diagnostic information in this project.
        Serial.begin(9600);
    
        //Configure ledPin as an output
        pinMode(ledPin, OUTPUT);
    
        //Announce the start of program. Usually a
        //hyper-terminal is connected to the serial
        //port on the PC so this message can be seen
        //there
        Serial.println("Ready.");
    
        //Enter the infinite loop responsible for making
        //the microcontroller do the same thing over and
        //over again. (Almost every microcontroller has
        //such a loop)
        while(true)
        {
            //Turn on the LED
            digitalWrite(ledPin, HIGH);
            //Wait for half of "interval".
            //The LED remains ON during this time.
            delay(interval/2);
            //Turn off the LED
            digitalWrite(ledPin, LOW);
            //Wait for half of "interval".
            //The LED remains OFF during this time.
            delay(interval/2);
        }
    
        //Unreachable code but it's required by
        //the compiler
        return 0;
    }
  4. Ahora compile el proyecto. !es posible que tenga  un montón  de errores!
  5. OK vamos a arreglarlos. Haga clic derecho sobre el proyecto de “Social” y elija “Propiedades” e ir a la “construcción de C/C++-> Configuración -> Avr Compiler -> directorios” opción y haga clic en el icono “+”.
  6. Haga clic en el botón “área de trabajo…” en el cuadro de diálogo subsecuente y elija Arduino -> Debug en el cuadro de diálogo el posterior.
  7. Finalmente se debe ver la siguiente. Haga clic en Aceptar después de haber verificado la ruta.
  8. Hacer lo mismo para la “construcción de C/C++-> Configuración -> Avr C++ Compiler -> directorios”
  9. Ir a “construir de C/C++-> Configuración -> Avr C++ linker -> bibliotecas” y defina las siguientes opciones.
  10. Ahora compilar el proyecto social otra vez. Compruebe que es mucho mejor ahora, pero todavía tenemos un error . Esto es un error de vinculador. El vinculador se queja aquí que no podría encontrar una aplicación para la función de llamada en cualquier lugar aunque se refiere a / usado en otras partes del código. Baste decir la función es necesaria por el runtime de C++ para decidir lo que hay que hacer cuando alguien llama a una función virtual pura directamente. Como recordará de sus tratos con C++, una función virtual pura no se puede llamar directamente sin proporcionar una implementación en alguna clase derivada. Para ello, una clase con una función virtual pura no puede ser instanciada en todos pero el runtime de C++ le gusta estar preparado para cualquier eventualidad.Compiladores avanzados habrían lanzado una excepción de esta función para indicar una operación ilegal, pero como no tenemos los de la plataforma de WinAVR, todo lo que podemos hacer es evitar  más daño que está haciendo entrar en un bucle sin fin (suponiendo que el programa es corriendo frenéticamente en primer lugar ya que ha hecho lo imposible por llamar a una función virtual pura directamente!)
    Nota: esto debe hacerse sólo para la versión de depuración. Al parecer esta función no se utiliza en la versión de lanzamiento de Arduino. Las compilaciones de depuración están amañadas para fallar rápidamente para que el punto de falla es lo más cercano posible al lugar donde está el verdadero problema.
  11. Agregar un nuevo archivo .c al proyecto Arduino (Nota debería ser .c y no CPP). Llame al missing.c y pegue el código siguiente en él y construir de nuevo ambos proyectos. El error debería desaparecer. Tenga en cuenta que lo necesario para construir Arduino antes de poder construir social.
    void __cxa_pure_virtual()
    {
        while(1);
    }
  12. Conmutando el panel de “Consola”, puede ver el resultado de ejecutar el comando tamaño de avr en el archivo .elf de generado…Pero no es un bonito espectáculo para la vista. Un pobre programa intermitente led ocupa aproximadamente 62% del total de memoria de programa disponible. Pero no se asuste, estamos en la versión de depuración  de modo que obtendrá mejores resultados al cambiar a liberar estructuras.

Cambiar a la versión de lanzamiento

  1. Haga clic derecho en un proyecto y seleccione “configuraciones de generación -> Set activo -> Release 2”. Hacer esto para todos los proyectos.
    Nota: usted necesita volver a especificar todos los ajustes para la versión de lanzamiento como hiciste para hacerlo compilar la versión de depuración.

Optimización prematura

  1. Aquí es cómo vamos de mejor a impresionantes. A continuación se asegurará de que usted sólo paga por las funciones y secciones de datos que realmente se utilizan en el programa. Agregue los siguientes indicadores adicionales para el C y C++ compiladores en todos los proyectos
    -ffunction-sections -fdata-sections

    Añadir la siguiente bandera a las opciones del vinculador en todos los proyectos.

    -Wl,-gc-sections

     

  2. Reconstruir (en el correcto orden Arduino en primer lugar, social segundo.)

Cargar el programa en el Arduino

Ahora ha llegado el momento cuando usted puede cargar su primer programa de Arduino construido dentro de los confines cómodos de Eclipse.

  1. Haga clic derecho sobre el proyecto social y selecciona “Propiedades“. Ir a la página de AVRDude y haga clic en nuevo.
  2. Rellene el formulario siguiente:
    • Nombre de configuración: Arduino
    • Hardware del programador: Arduino
    • Reemplazar el puerto por defecto: \\.\COM3. Reemplazar el COM3 a cualquier puerto del hardware de Arduino está conectado a.
    • Override en baudios por defecto: 19200. Reemplazar 19200 a cualquier velocidad en baudios fue especificado por el fabricante del tablero / la persona que subido el Arduino boot loader en tu tarjeta.

     

  3. Seleccionar Arduino como programador en AVRDude configuración y haga clic en Aceptar.
  4. Haga clic en el botón de la barra de herramientas AVR para subir su programa a la placa.

    Debería ver algo como lo siguiente en la ventana de la consola…

    Launching C:\misc\WinAVR\bin\avrdude -pm328p 
        carduino "-P\\.\COM3" -b19200 -Uflash:w:BlinkenLights.hex:a 
    Output:
    
    avrdude: AVR device initialized and ready to accept instructions
    
    Reading | ################################################## | 100% 0.02s
    
    avrdude: Device signature = 0x1e950f
    avrdude: NOTE: FLASH memory has been specified, an erase cycle will be performed
             To disable this feature, specify the -D option.
    avrdude: erasing chip
    avrdude: reading input file "BlinkenLights.hex"
    avrdude: input file BlinkenLights.hex auto detected as Intel Hex
    avrdude: writing flash (2828 bytes):
    
    Writing | ################################################## | 100% 2.16s
    
    avrdude: 2828 bytes of flash written
    avrdude: verifying flash memory against BlinkenLights.hex:
    avrdude: load data flash data from input file BlinkenLights.hex:
    avrdude: input file BlinkenLights.hex auto detected as Intel Hex
    avrdude: input file BlinkenLights.hex contains 2828 bytes
    avrdude: reading on-chip flash data:
    
    Reading | ################################################## | 100% 2.14s
    
    avrdude: verifying ...
    avrdude: 2828 bytes of flash verified
    
    avrdude done.  Thank you.
  5. Si todo salió bien, la prueba a bordo del LED (generalmente color rojo) ahora si empieza a parpadear en cerca de 1 parpadeo/seg Felicitaciones!

Finalmente hemos visto cómo utilizar Eclipse para el desarrollo de AVR. Pero esto es sólo el principio pues hay mucho explorar pero hemos visto  los fundamentos y ahora debería ser fina por su cuenta. Los ejemplos y bibliotecas suministradas con Arduino deben ser un buen punto de partida para la exploración de más.

 

 

Fuente https://www.codeproject.com/Articles/110859/Arduino-Unleashed

 

 

Fácil monitorización de temperatura con Cayenne


Gracias  a la plataforma de Cayenne , de la que hemos hablado en este blog en numerosas  ocasiones es bastante sencillo monitorizar cualquier variable física  de un modo realmente sencillo  simplemente  haciendo drug &drop desde el panel de control de Cayenne

En este ejemplo  vamos a  ver lo facil que es crear monitor temperatura con Cayenne  , el  cual  utilizando internet sin tener conocimientos  de programación conseguir controlar o monitorizar lo que quiera  en tan solo unos minutos

En efecto   gracias  a un  framework  genérico desarrollado por  myDevices IO Project Builder llamado Cayenne , los desarrolladores , fabricantes y  también aficionados  pueden  construir rápidamente prototipos y proyectos que requieran controlar o monitorizar   cualquier cosa conectada a  una placa  con conectividad  , permitiendo con una sóla cuenta gratuita de Cayenne, crear un número ilimitado de proyectos  mediante una solución  muy sencilla  basada en arrastrar y soltar 

Obviamente el punto fuerte de cayenne  son las  capacidades de  IO  para que pueda controlar de forma remota sensores, motores, actuadores, incluidas los puertos  de GPIO con almacenamiento ilimitado de datos recogidos por los componentes de hardware,   triggers y alertas,  que proporcionan las herramientas necesarias para la automatización y la capacidad de configurar alertas. Ademas también puede crear cuadros de mando personalizados para mostrar su proyecto con arrastrar y soltar widgets que también son totalmente personalizables.

Resumidamente algunas  características clave de esta novedosa  plataforma son las siguientes:

  • Una aplicación móvil para configurar, el monitor y los dispositivos de control y sensores desde cualquier lugar.
  • Fácil instalación que conecta rápidamente los dispositivos, sensores, actuadores, y las extensiones en cuestión de minutos.
  • Motor de reglas para desencadenar acciones a través de dispositivos.
  • Panel personalizable con widgets de visualización de arrastrar y soltar.
  • Programación de las luces, motores y actuadores
  • Control de puertos que se pueden configurar desde una aplicación móvil o  desde un navegador
  • Acceso remoto instantáneo desde su smartphone o con un ordenador
  • Para construir un proyecto de la IO a partir de cero se ha logrado el objetivo de proporcionar  un Proyecto Generador de IO que reduce el tiempo de desarrollo de horas en lugar de meses.

Como veremos , hablamos de un constructor de sitio web fácil de usar, pero para proyectos de IOT, así que veamos  los pasos para crear un proyecto de IoT con esta potente herramienta usando  en esta ocasión un clon de Arduino con wifi : el ESP8266

Hardware y Software

Picture of Hardware and Software  Picture of Hardware and SoftwarePicture of Hardware and Software

El hardware  y software a que necesitaremos es el que siguiente:

 

Sensor DHTXX

DHT11 y  DHT22 son dos modelos de una misma familia de sensores, que permiten realizar la medición simultánea de temperatura y humedad usando ademas un único  hilo para comunicar los datos vía serie, para lo cual  ambos  disponen de un procesador interno que realiza el proceso de medición, proporcionando la medición mediante una señal digital, por lo que resulta muy sencillo obtener la medición desde un microprocesador como Arduino o ESP8266.

Ambos son similares ( DHT11 presenta una carcasa azul  , mientras que el sensor DHT22  es blanco)  compartiendo además los mismos pines  disponiendo de  4 patillas, de las cuales usaremos sólo 3: Vcc, Output y GND.  Como peculiaridad ,la  salida la conectaremos a una entrada digital  , pero necesitaremos poner una resistencia de 10K entre Vcc y el Pin Output.

El  DHT11  puede medir temperaturas entre 0 a 50, con una precisión de 2ºC, humedad entre 20 a 80%, con precisión del 5% y con una a frecuencia de muestreo de 1 muestras por segundo (1 Hz)

En clara superioridad  con el dHT11 , el modelo DHT22 tiene unas características mucho más profesionales.
  • Medición de temperatura entre -40 a 125, con una precisión de 0.5ºC
  • Medición de humedad entre 0 a 100%, con precisión del 2-5%.
  • Frecuencia de muestreo de 2 muestras por segundo (2 Hz)

Destacar que este tipo de  sensores de temperatura  ( y, aún más, los sensores de humedad) , son sensores con elevada inercia y tiempos de respuesta elevados. Es decir, al “lentos” para reflejar los cambios en la medición.

Conectar el DHT11   o el DHT22  a  un Arduino o ESP82366  es sencillo, simplemente alimentamos desde Arduino al sensor a través de los pines GND y Vcc del mismo. Por otro lado, conectamos la salida Output a una entrada digital de Arduino. Necesitaremos poner una resistencia de 10K entre Vcc y el Pin Output.

El esquema eléctrico queda como la siguiente imagen:

arduino-dht11-dht22-esquema

Los sensores DHT11 y DHT22 usan su propio sistema de comunicación bidireccional mediante un único hilo , empleando señales temporizadas por lo que en general, lo normal es que empleemos una librería existente para simplificar el proceso.Por ejemplo podemos usar la librería de Adafruit disponible en este enlace.

Conexión de DHT22 a  ESP12E

El  ESP12E    esta basado en Arduino  pero cuenta   también conectividad wifi integrando la propia antena en la placa de circuito impreso en unas  dimensiones de  25.6mm x 34.2mm .  Además, por motivos de reducción de espacio esta placa no integra conexión usb  , para lo cual necesitaremos un USB FTDI   para programarlo o un  controlador Setup CH340g.

Esta placa cuenta con 11 pines digitales de entrada / salida, todos los pines tienen interruptor / pwm / I2C / 1-wire    siendo su chip principal el  ESP8266 CH340G

Una gran diferencia con una placa Arduino es que solo cuenta  con 1 entrada analógica (entrada máxima de 3,3 V)

 

Como  vemos el circuito para conectar al  ESP12E      un sensor de temperatura  no puede ser más sencillo, pues     simplemente alimentaremos con 3.3v DC tanto el DHT22 como el  ESP12E        en sus  pines correspondiente     sin olvidar  que la salida de datos del DH22(pin datos )    tenemos que conectarla al  pin 5 del GPIO

 

 

 Programar el  ESP12E

Para  probar Cayenne  con el  ESP12E       necesitamos  programar su ESP-12E para conectarse a su punto de acceso wifi   . El código fuente a subir  se puede descargar desde https://codebender.cc/embed/sketch:398516

Básicamente  el código a subir al    ESP12E     usa 5 librerías:  tres de Cayenne donde  tendremos que definir el SSID y la pwd de la red wifi asi como las credenciales de Cayenne    , una cuarta de temporización para enviar muestras a intervalos prefijados ( que obviamente podemos cambiar ) y por último la mencionada para la gestión del DTHXX

Es de destacar  la creación  de  dos puertos virtuales  para capturar  los valores  en tiempo real de la temperatura  y la humedad tomadas ambas  del DHTXX  , lo cual nos van a permitir comunicarnos con el API de Cayenne

 

#include "CayenneDefines.h"
#include "CayenneWiFi.h"
#include "CayenneWiFiClient.h"
#include <SimpleTimer.h>
#include "DHT.h"

#define CAYANNE_DEBUG
#define CAYANNE_PRINT Serial
#define DHTPIN 5
#define DHTTYPE DHT22 // DHT 22 (AM2302), AM2321

// Cayenne authentication token. This should be obtained from the Cayenne Dashboard.
// Change the value of token, ssid, and pwd to yours
char token[] = "xxxxxx";
char ssid[] = "xxxxxx";
char pwd[] = "xxxxx";
DHT dht(DHTPIN, DHTTYPE);

void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
Cayenne.begin(token, ssid, pwd);
dht.begin();
}

CAYENNE_OUT(V0)
{
float t = dht.readTemperature();
Cayenne.virtualWrite(V0, t); //virtual pin
}

CAYENNE_OUT(V1)
{
float h = dht.readHumidity();
Cayenne.virtualWrite(V1, h); //virtual pin
}

void loop() {
Cayenne.run();
}

Importante:  Necesitaremos actualizar  en el código anterior cambiando el valor de ssid, contraseña  configurandola para la red wifi de su hogar y  también no olvidar   registrar  el  token de Cayenne que previamente habrá solicitado  desde la propia web de cayenne.

Configuración Cayenne Dashboard

Hemos hablado en  muchas ocasiones de Cayenne  pues en realidad está concebido para  que su manejo sea realmente sencillo   de configurar

Nos iremos a  su   url :   https://cayenne.mydevices.com/  

Tras registrarnos nos iremos  al panel de control   ,clicamos en  Add new   y seleccionamos generic ESP8266

A continuación nos ofrece  la API key que deberemos añadir al sw del   ESP12E      y tras reiniciarlo  ya debería poderse  comunicar con el node de Cayenne

 

Si la placa  pues   está configurada con el MQTT  ( username /pwd)     asi como con conectividad  wifi ,  ya   debería  de  poder conectarse al framework de Cayenne   y podemos seguir hacia adelante añadiendo sensores que deberan estar de acuerdo con el sw instalado en el ESP12E

En este caso como hemos definido  dos puertos virtuales para temperatura y humedad el firmware del ESP12E  , necesitamos añadir dos widgets  asociados a esos dos canales:

Para la temperatura  no olvidar que habíamos asignado el primer puerto virtual, el cual ue debemos asignar al widget:
Para la humedad   no olvidar que habíamos asignado el segundo puerto virtual, el cual ue debemos asignar al widget:
Finalmente al asignar los dos widgets  , si esta la placa conectada , debería mostrar un panel similar al siguiente  en el que se jha añadido un widget nuevo asociado al puerto analogico

Configuración de su primer  trigger

Los triggers  o disparadores en Cayenne son una forma de hacer que su placa  reaccione a un cambio  de un sensor conectado a él. Esto podría ser algo tan simple como un valor de temperatura superior a un cierto valor o incluso sólo si el ESP12E pierde la conexión, lo cual como se podría imaginar puede ser muy potente en la creación de dispositivos inteligentes que reaccionan a los alrededores ( como por ejemplo, si la habitación se pone demasiado fría, encienda un  calefactor, etc ).

El proceso de agregar un disparador es muy sencillo como vamos a ver a continuacion:

  1. Ir a añadir en la esquina superior izquierda del tablero de instrumentos.
  2. Seleccionar un trigger desde el cuadro de abajo.
  3. El nombre de su trigger, voy a llamar a la mía “demasiado caliente”.
  4. Ahora arrastrar y soltar su  ESP12E  desde la esquina izquierda en el caso de la caja.
  5. Por debajo de esto seleccionar el sensor de temperatura y tienen casilla junto a “por encima de la temperatura” seleccionado. (Si las opciones del dispositivo no se muestran simplemente actualizar la página)
  6. Ahora en el cuadro de selección a continuación, notificación y agregar una dirección de correo electrónico o número de teléfono de un mensaje de texto (puede agregar ambos).Asegúrese de marcar las casillas de verificación también.Dispara demasiado caliente
  7. Ahora haga clic en “Save trigger”.
  8. Ahora se debe guardar y le enviará una alerta cada vez que el sensor de temperatura es más de 40 grados Celsius.
  9. También puede arrastrar el ESP12E en el cuadro a continuación, y tienen que hacer muchas cosas, incluyendo el control de los dispositivos de salida. Por ejemplo, puede  añadir un LED que se activará cuando la temperatura supere los 40 grados Celsius.
  10. Para hacer clic en el gatillo de disparo LED de nueva situada en la parte superior de la página. Nombre esta activar el gatillo LED.
  11. Ahora arrastrar el Pi en el caso de la caja y luego seleccione el sensor de temperatura de nuevo con 40 grados centígrados por encima.
  12. Ahora arrastrar el ESP12E  en cuadro a continuación. Seleccione nuestra salida digital y marque la casilla de verificación activada.
  13. Ahora haga clic en Save trigger.
  14. Ahora, cada vez que nuestro sensor de temperatura conectado al Pi informe una temperatura superior a 40 grados Celsius, enviará un correo electrónico y encenderá el LED.También necesitará agregar otro disparador para apagar el LED cuando caiga por debajo de los 40 

Mydevices cayennem Disparadores

 

 

 

Sin duda hay infinitas posibilidades como el lector   puede imaginar

 

Ayuda robotica


Tercera Mano Robótica  es un kit de fuente abierta cuyas piezas se pueden  imprimir  en una impresora 3D y que se puede  usar en el antebrazo utilizando  un Trinket Pro como cerebro

Trinket es una versión reducida de un Arduino con un ATmega328 y de coste reducido, pero obviamente puede usarse cualquier  placa que sea compatible con Arduino

Cuando se le solicite, puede entregarle una herramienta que tenga, liberándolo de buscarlo o perderlo  todo ello pulsando un único pulsador que Tim (su creador) ha colocado estratégicamente en un dedo gracias a una pieza  similar a un anillo  impresa también en  3d

 

En realidad  son pocos componentes los usados en este proyecto:

  • 1x9g servo hobby barato
  • Trinket Pro 5V
  • Cargador de batería de litio de celda única (3.7V)  alimentado a 5V
  • Batería de  300mAH celda única LiPO
  •  imanes – 5/16 “de diámetro, 1.8” de espesor
  • 13 × 2-56 tornillos
  • 1 × piezas impresas en 3D
  • Banda de cintura elástica ancha 1 × 1 “

Después de reunir todos los elementos en la lista de componentes e imprimir sus piezas, ¡es hora de comenzar el ensamblaje y conectarlo todo!

 

Aquí está el diagrama de conexión:

 

Es bastante simple  pues se limita a conectar la placa a  un servo controlado por el puerto digital nº8   y que ira alimentando a la salida del cargador a 5v DC   y  un pulsador que conectaremos  al pin 3   y masa .

El resto es simplemente  la parte de carga de la batería que se conectará  por un lado a la batería   y por otro lado tanto al servo  como a  la placa de control  .

Puesto que la alimentación es suministrada por la batería se recomienda colocar un interruptor en la batería para impedir su descarga  cuando no se esta usando.

Aquí está el código para hacer su movimiento robótico de tercera mano:

// ThirdHand test script
// by Tim Giles <www.wildcircuits.com>

//servo is on Pin8
//button is on Pin3 and has the pullup enabled

#include 

Servo ServoA;

int Angle = 10;
int AngleClosed = 10;
int AngleOpen = 120;

void setup()
{
  ServoA.attach(8);
  pinMode(3,INPUT_PULLUP);
}

void loop()
{
  //update the servo position
  ServoA.write(Angle);
  delay(1);
  
  //check if the button is pushed
  if (digitalRead(3) == 0)
  {
    //debounce
    while (digitalRead(3) == 0){
      delay(1);
    }
    //set the servo to it's open position
    Angle = AngleOpen;
    ServoA.write(Angle);
    //hold the servo in this position to give the user time
    //to grab the screwdriver
    delay(2000);
    //set the servo to it's closed position
    Angle = AngleClosed;
    ServoA.write(Angle);
  }
}

Durante la programación se  recomienda desconectar la batería pues de lo contrario, el suministro de refuerzo de 5 V volverá a alimentar su ordenador y puede generar efectos negativos

Si su cable USB que está programando es demasiado largo / demasiado débil, es posible que tenga un comportamiento extraño cuando termine la programación y el servo intente moverse:esto se debe a una caída de voltaje excesiva en el cable USB que hace que el Trinket Pro se reinicie cuando el servo intenta moverse.

 

PIEZAS  IMPRESAS EN 3D

robotic

La base  , el bazo articulado  así como el anillo para el pulsador   se han realizado impresas en 3D

Los ficheros están disponibles como no en el repositorio Thingiverse  en la  url   https://www.thingiverse.com/thing:618811

Mientras ensambla las piezas impresas en 3D, notará que todos los orificios de los tornillos son ligeramente más pequeños o de mayor tamaño.

Los tornillos 2-56 se ensartarán automáticamente en los orificios de menor tamaño y girarán libremente en los orificios de mayor tamaño, lo cual  permite que el tornillo sujete firmemente la bandeja del destornillador mientras que el brazo que acciona la bandeja del destornillador se puede mover libremente.Si sus piezas no van juntas así, entonces necesitará ajustar su impresora o ajustar el tamaño de los orificios de los tornillos.

 

Fuente hackaday.io