Entorno requerido

Ameba actualmente soporta Windows XP / 7/8 32 y 64 bits y sistemas operativos MAC OS. Utilice IDE de Arduino con la versión 1.6.5 o posterior.

Introducción a Ameba RTL8710

Ameba RTL8710 es similar a Ameba RTL8195, ambos son adecuados para desarrollar todo tipo de aplicaciones IoT. Ameba está equipado con varias interfaces periféricas, incluyendo WiFi, GPIO, I2C, UART, SPI y así sucesivamente. Puede conectarse con componentes y módulos comunes de Arduino a través de estas interfaces. A diferencia de Arduino, puede cargar datos en la nube a través de WiFi incorporado directamente para realizar la implementación de IoT.

Tal vez pueda interesarte proyectos en arduino, pic, robótica, telecomunicaciones, suscribete en http://www.youtube.com/user/carlosvolt?sub_confirmation=1 mucho videos con código fuentes completos y diagramas.

---

Configuración del entorno de desarrollo

Paso 1. Instalación del controlador MBED

Si ya había instalado RTL8195A antes, puede saltarse este capítulo e ir a “Configuración de IDE Arduino”. En primer lugar, conecte RTL8710 a la computadora a través de Micro USB:

Si es la primera vez que conecta Ameba a su computadora, tiene que instalar el controlador USB para Ameba. Ameba utiliza el controlador ARM MBED CMSIS DAP estándar, puede obtener el archivo de instalación y la información relacionada en el siguiente sitio web:

Https://developer.mbed.org/handbook/Windows-serial-configuration

Descargue e instale “mbedWinSerial_16466.exe” en “Descargar el controlador más reciente”. Posteriormente, verá “puerto serie de mbed” en el Administrador de dispositivos de su computadora:

Paso 2. Configure Arduino IDE

Desde la versión 1.6.5, el IDE de Arduino soporta hardware de terceros. Por lo tanto, podemos usar Arduino IDE para desarrollar aplicaciones en Ameba, y los ejemplos de Arduino pueden ejecutarse en Ameba también. Arduino IDE se puede descargar en el sitio web de Arduino:

Https://www.arduino.cc/en/Main/Software

Abra el IDE de Arduino después de la instalación. Para que Arduino IDE pueda encontrar el archivo de configuración de Ameba. Ir a “Archivo” -> “Preferencias”

Y pegue la siguiente URL en el campo “Additional Boards Manager URLs”:

https://github.com/Ameba8195/Arduino/raw/master/release/package_realtek.com_ameba_index.json

Además, si la versión IDE que utiliza es anterior a 1.6.7, asegúrese de que el IDE esté configurado en inglés para evitar problemas de idioma.
En la versión 1.6.7, Arduino ha resuelto el problema de idioma.

 

Reinicie el IDE de Arduino para activar la configuración.

A continuación, vaya a “Herramientas” -> “Board” -> “Boards Manager”:

 

El “Boards Manager” requiere unos 10 ~ 20 segundos para actualizar todos los archivos de hardware (si la red está en mal estado, puede tomar más tiempo). Cada vez que el nuevo hardware está conectado, necesitamos reabrir el Administrador de la placa. Así que cerramos el Boards Manager y lo abrimos de nuevo. Encontrar “Realtek Ameba Boards” en la lista y admite Ameba RTL8710 después de la versión 2.0.0, haga clic en “Instalar”, a continuación, el Arduino IDE comienza a descargar los archivos necesarios para Ameba.

 

 

A continuación, seleccione Ameba como placa conectada actual en “herramientas” -> “BOARD” -> “Ameba RTL8710”:

 

Termine la configuración del entorno de desarrollo.

Prueba el primer ejemplo

Paso 1. Compilar y cargar

Arduino IDE proporciona muchos ejemplos integrados, los cuales pueden ser compilados, cargados y ejecutados directamente en las tablas. Aquí, tomamos el ejemplo de “Blink” como el primer intento.
Abrir “Archivo” -> “Ejemplos” -> “01.Basics” -> “Blink”

 

 

Arduino IDE abre una nueva ventana con el código de ejemplo completo.
Hay una breve explicación en la parte superior del código de ejemplo. Tome “Blink” como ejemplo, indica que si usa UNO, MEGA, ZERO entonces tiene que conectarse al pin 13. Y el ajuste Ameba es el mismo con el ajuste UNO en este ejemplo.

 

 

A continuación, compilar el código de ejemplo directamente, haga clic en “Sketch” -> “Verify / Compile”

 

 

Arduino IDE imprime los mensajes de compilación en el área inferior de la ventana IDE. Cuando finalice la compilación, obtendrá los mensajes similares que se muestran a continuación:

 

 

Posteriormente, subiremos el código compilado a Ameba. Asegúrese de que Ameba esté conectado a su computadora, luego haga clic en “Sketch” -> “Upload”

 

 

Una vez más, durante el proceso de carga, el IDE imprime los mensajes. El procedimiento de carga requiere un tiempo más largo (aproximadamente 30 segundos a 1 minuto). Cuando se completa la carga, se imprime el mensaje “Finalizar carga”.

 

Paso 2. Ejecutar el ejemplo de parpadeo

Finalmente, presione el botón de reinicio, y podrá ver el LED parpadeando.

Module Parámetros:

1.Wireless Standard:802.11 b/g/n
2.Frequency Range:2.4GHz-2.5GHz
3.CPU:ARM Cortex M3 (83MHz)
4.ROM/RAM/Flash:1MB/512KB/1MB
5.PWM:most support 4pcs
6.SPI:most support 1pc
7.UART:2 high-speed serial ports (max baud rate 4Mbps),1 low-speed serial port
8.I2C:most support 1pc
9.GPIO:most support 17pcs
10.Operating Voltage:3.0-3.6V (recommend 3.3V)
11.Operating Temperature:-20~85 celsius
12.Storage Temperature:normal temperature
13.Wireless Network Mode:station/softAP/SoftAP+station
14.Security Mechanism:WPA/WPA2
15.Encryption Type:WEP/TKIP/AES
16.Upgrade Firmware:local serial port programming/Cloud Client upgrade/host download programming
17.Software Development:support customer self-defined server
18.Network Protocol:TCP/UDP/HTTP/FTP/SNTP/MQTT/SMTP
19.User Configuration:AT+ instruction set,Cloud server,Android/iOS APP
20.SDK:open source,support win and linux

Para comprar este producto visita el siguiente enlace Módulo WIFI RTL8710AF con placa de desarrollo MJIOT-AMB-01 

Tal vez pueda interesarte proyectos en arduino, pic, robótica, telecomunicaciones, suscribete en http://www.youtube.com/user/carlosvolt?sub_confirmation=1 mucho videos con código fuentes completos y diagramas.

SUSCRIBETE A NUESTROS BOLETINES, RECIBE EN TU CORREO LAS NOTICIAS MÁS DESTACADAS, SÓLO INGRESANDO TU CORREO ELECTRÓNICO

Buenos días en esta entrada veremos la configuración del módulo ESP32 con el entrono de desarrollo de Arduino, tambien crearemos un programa para subir datos de la temperatura al cloud de https://thingspeak.com y gracias al aporte y colaboración de www.icstation.com pudo obtener gratis este módulo para su evaluación y revisión.

El módulo ESP32 es un módulo creado por la empresa Espressif Systems, la misma que nos trajo el legendario esp8266 que es tan apreciado, y amado por la comunidad maker.

Tal vez pueda interesarte proyectos en arduino, pic, robótica, telecomunicaciones, suscribete en http://www.youtube.com/user/carlosvolt?sub_confirmation=1 mucho videos con código fuentes completos y diagrama

Caracteristicas del módulo ESP32-T

Conectividad

El módulo ESP32 dispone de todas las variantes del WiFi:

• 802.11 b/g/n/e/i/n
• Wi-Fi Direct (P2P), P2P Discovery, P2P Group Owner mode and P2P Power Management

Esta versión nueva incluye la conectividad mediante Bluethoot de bajo consumo

• Bluetooth v4.2 BR/EDR and BLE
• BLE Beacon

Además, puede comunicarse mediante los protocoles SPI, I2C, UART, MAC Ethernet, Host SD

Prestaciones del microcontrolador

La CPU está formado por un SoC modelo Tensilica LX6 con las siguientes características y memoria

• Doble núcleo de 32 bits con velocidad de 160MHz
• Memoria ROM de 448 kBytes
• Memoria SRAM de 520kBytes

Dispne de 48 Pines

• 18 ADC de 12 bits
• 2 DAC de 8 bits
• 10 pines sensores de contacto
• 16 PWM
• 20 Entradas/salidas digitales

Alimentación y modos de consumo

Para un correcto funcionamiento del ESP32 es necesario subministrar un voltaje de entre 2,8V y 3,6V. La energía que consume depende del modo de funcionamiento. Contiene un modo, el Ultra Low Power Solution (ULP), en que se continúan realizando tareas básicas (ADC, RTC…) en el modo Sleep.

ESP8266 versus ESP32

Pin Out

Pin Out ds18b20

Código fuente

#include <WiFi.h>//Descomentar si vamos a usar el sensor con el ESP32
//#include <ESP8266WiFi.h>//Descomentar si vamos a usar el sensor con el ESP8266
#include <DallasTemperature.h>//Librería para el manejo del sensor de temperatura ds18b20
#define GPIO4 4 //Tener en cuenta que el pin es el GPIO, siempre mirar el pinout en el datasheep del módulo
#define GPIO2 2 //Led GPIO 2
OneWire ourWire(GPIO4); //Se establece el pin declarado como bus para la comunicación OneWire
 
DallasTemperature sensors(&ourWire); //Se instancia la librería DallasTemperature
// Configuración Wi-Fi
const char* ssid = "xxxxxxxx"; // Reemplazar por el nombre de tu red inalámbrica (SSID)
const char* password = "xxxxxx"; // Cambiar por tu contraseña de red Wifi
WiFiClient client;

// Seteo de datos para ThingSpeak.com
const int channelID = 111111;//Identificación del canal (se obtiene de ThingSpeak.com)
String writeAPIKey = "xxxxxxxxxxxxx"; //Clave de escritura API para su canal (se obtiene de ThingSpeak.com)
const char* server = "api.thingspeak.com";
const int intervalo = 15000; // Publicar datos cada 15 segundos( el mínimo es 15 segundos en la versión de prueba)

void setup() {
delay(1000);
sensors.begin(); //se inicia el sensor ds18b20
  Serial.begin(115200);//Seteo de la velocidad del puerto serial
  WiFi.begin(ssid, password);//Seteo red wifi y contraseña
  pinMode(GPIO2, OUTPUT);//Seteo del led como salida
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
  }
  }

void loop() {
  if (client.connect(server, 80)) {//conexión a travez del puerto 80
sensors.requestTemperatures(); //Prepara el sensor para la lectura
float datoSensor = sensors.getTempCByIndex(0); // getTempCByIndex(0) se refiere al primer sensor si es que tubieramos más de uno conectado en el cable
//Imprimimos en el terminal serial del arduino el valor de la lectura tomada en el sensor de temperatura
Serial.print("Temperatura en celcius: ");
Serial.println(datoSensor); 
   
    // Construir el cuerpo de solicitud de API
    String body = "field1=";
           body += String(datoSensor);    
    client.print("POST /update HTTP/1.1\n");
    client.print("Host: api.thingspeak.com\n");
    client.print("Connection: close\n");
    client.print("X-THINGSPEAKAPIKEY: " + writeAPIKey + "\n");
    client.print("Content-Type: application/x-www-form-urlencoded\n");
    client.print("Content-Length: ");
    client.print(body.length());
    client.print("\n\n");
    client.print(body);
    client.print("\n\n");
  }
  client.stop();

  //Genera un pequeño parpadeo indicando se ha enviado un dato
    digitalWrite(GPIO2, HIGH);
  delay(200);
  digitalWrite(GPIO2, LOW);
  // espera el tiempo seteado para luego vulver a publicar
  delay(intervalo);

Circuito

Pasos para instalar soporte de Arduino ESP32 en Windows

Probado en máquinas Windows 10 de 32 y 64 bits

1. Descargue e instale el último Arduino IDE Windows Installer de arduino.cc
2. Descargue e instale Git desde git-scm.com
3. Inicie la interfaz gráfica de usuario de Git y ejecute los siguientes pasos:
   • Seleccionar Clonar Repositorio Existente
   • Seleccionar origen y destino
     • Ubicación de la fuente: https://github.com/espressif/arduino-esp32.git
     • Directorio de destino: C:/Users/[Tu_Nombre_de_Usuario]/Documents/Arduino/hardware/espressif/esp32
     • Cambie esto a su ubicación de Sketchbook si tiene un directorio diferente que aparece debajo de la “Ubicación de Sketchbook” en las preferencias de Arduino.
     • Haga clic en Clonar para iniciar la clonación del repositorio 
   • Abrir C:/Users/[Tu_Nombre_de_Usuario]/Documents/Arduino/hardware/espressif/esp32/tools y doble click enget.exe
   • Cuando get.exe termine, debería ver los siguientes archivos en el directorio
     
4. Enchufe su tarjeta ESP32 y espere a que los controladores instalen (o instale manualmente los que sean necesarios)
5. Iniciar el IDE de Arduino
6. Selecciona tu placa en Herramientas> Menú de placa
7. Seleccione el puerto COM al que está conectada la placa
8. Compilar y cargar (Es posible que deba mantener pulsado el botón de arranque “KEY” mientras carga)
   

Cómo actualizar al código más reciente

1. Inicie Git GUI y debería ver el repositorio en Abrir Repositorio Reciente.
2. Desde el menú Remoto seleccione Buscar de> Origen
3. Espere a que git tire de los cambios y cierre Git GUI
4. Abrir C:/Users/[Tu_Nombre_de_Usuario]/Documents/Arduino/hardware/espressif/esp32/tools y doble click en get.exe

Configuración del ESP32 con el IDE de Arduino

Una vez termina el proceso instalación de todo el software para el ESP32-t debemos ir al IDE de arduino, revisamos en “Herramientas” – “Placas” y verificamos si aparecieron nuevas placas y elegimos ESP32 DEV MODULE

A continuación elegimos el puerto COM correcto, ya estamos en condiciones de programas nuestro ESP32.

Pueden adquirir el producto en ICStation en ESP32-T WiFi IOT ESP32 Module Development Board Module Suite ESP32-Bit Wireless WiFi Module

Aclaración importante!!! El módulo hay que soldarlo a la placa.

Tal vez pueda interesarte proyectos en arduino, pic, robótica, telecomunicaciones, suscribete en http://www.youtube.com/user/carlosvolt?sub_confirmation=1 mucho videos con código fuentes completos y diagrama

SUSCRIBETE A NUESTROS BOLETINES, RECIBE EN TU CORREO LAS NOTICIAS MÁS DESTACADAS, SÓLO INGRESANDO TU CORREO ELECTRÓNICO

Introducción

Wido es una placa de desarrollo de Nodo IoT WIFI compatible con Arduino, la cual se integra con la solución WG1300 WIFI (CC3300). También posee un microcontrolador  ATMEL ATmega32U4.

Especificación

• Rango de fuente de alimentación: 5v o 7-12v
• Compatible con Arduino Leonardo
• Integrar con el chip WG1300 WIFI y soporte 2.4GHz IEEE 802.11 b / g de red
• WIFi y MicroSD impulsado por el puerto SPI
• Antena PCB 2.4G a bordo
• Pines del driver:
  • Módulo WIFI-D7 (IRQ), D5 (VBAT), D10 (CS), D14 (MISO), D15 (SCK), D16 (MOSI)
  • MicroSD – D4 (CS), D14 (MISO), D15 (SCK), D16 (MOSI)

¿En que podemos utilizar WIDO?

• Comunicaciones de sensores M2M
• Juguetes
• Soluciones IoT
• Dispositivo
• Smart Home

PinOut

Librería modificada por DFROBOT

Adafruit_CC3000_Library-master

Librería creada por Adafruit

Adafruit_CC3000_Library

En el video tutorial voy a utlizar esta librería, pero sólo porque tiene un firmware más actualizado, si no desean actualizar recomiendo la librería de de DFROBOT, tener en cuenta que WIDO usa el IRQ 7 y no el 3 como figura en la librería de Adafruit.

Diagrama esquemático de WIDO

DFR0321_V1.0_Schematic

DataSheet WG1300

WG1300 datasheet

¿Donde comprar? WiDo – An Arduino Compatible IoT (internet of thing) Board

Actualización del Firmware de WIDO

Recordemos que necesitamos tener instada la librería de Adafruit, puden descargarla, fácilmente desde el IDE de arduino siguiendo estos pasos

Escribimos en el gestor de librerías CC3300, e instalamos la de Adafruit, si no también puedes descargarla de este mismo sitio.

Ahora buscaremos el el ejemplo llamado builtest, y lo abrimos

Debemos modificar el IRQ por el 7 y cambiar el nombre de nuestra red wifi y clave, como se indica en la siguiente imagen

Ahora vamos a actualizar el firmaware las versiones recientes de arduino presentar un error.

La solución es descargar la versión del IDE 1.0.6, cambiamos el IRQ por el 7

Nos saldrá un error al tratar de subir el código, por la falta de espacio en el arduino leonardo. Lamentablemente no hay documentación que indique como resolverlo

Se me ocurrió una solución ¿Pero funcionará?

Resulta que la actualización, acatualiza el driver y tambien el firmware, entonces haremos por partes este procedimiento.

Vamos a ir a la pestaña que dice driverpatchinch_1_14 y comentamos desde uint8_t cRMdefaultParams[128] hasta uint16_t drv_length = 7036;

Ahora intentamos compilar y aparecerá un error en la linea  pRMParams = (uint8_t *)cRMdefaultParams; asi que simplementa tambien la comentamos,

volvemos a compilar y esta linea tambien dará error  ucStatus_Dr = nvmem_write_patch(NVMEM_WLAN_DRIVER_SP_FILEID, drv_length, wlan_drv_patch); y la comentamos listo ahora subimos el código a WIDO

Ahora abrimos el monitor serial escribimos un caracter cualquiera y empezará la actualización, recomiendo esperar un par de minutos antes de continuar

Antes de continuar tenemos que desacer todos los cambios hechos al codigo apretando control-z para desacer, a continuación no olvidar cambiar el IRQ por el 7

Ahora comentamos la segunda parte y compilamos

Nos dará un error y comentamos la siguiente linea, ahora si subimos el

Ahora abrimos el monitor serial escribimos un caracter cualquiera y empezará la actualización, recomiendo esperar un par de minutos antes de continuar, igual que en el paso anterior, recomiendo ver el video para ver el proceso completo y más detallado

Builtest antes y después de la actualización

Código fuente subido en el servidor rogerbit.com

Para escribir algo en el servir hacer click aquí

http://rogerbit.com/datos/destino.php?id=Hola,mundo!!!

Si querermos escribir algo distinto cabiamos la leyenda en wido o en nuestro navegador donde dice Hola,mundo!!! por lo que quieres escribir

Para visualizarlo entra a este link http://rogerbit.com/datos/archivo.html

<html>  
<head>  
<title>Susucrite al canal de CarlosVolt.</title>  
</head>  

<body>  
<!-- Hola amigo hemos recibido el dato en RogerBit.com suscribete en el canal www.youtube.com/user/Carlosvolt--> 

<?php 
$dato = $_GET['id']; 

echo "El dato es: $dato";

$file = fopen("archivo.html", "a");
fwrite($file, $dato  . PHP_EOL);
fclose($file);
?> 
</body> 
</html>

Para más información de esta placa recomiendo visitar https://www.dfrobot.com/wiki/index.php/Wido-WIFI_IoT_Node_SKU:DFR0321

Tal vez pueda interesarte proyectos en arduino, pic, robótica, telecomunicaciones, suscribete en http://www.youtube.com/user/carlosvolt?sub_confirmation=1 mucho videos con código fuentes completos y diagrama

SUSCRIBETE A NUESTROS BOLETINES, RECIBE EN TU CORREO LAS NOTICIAS MÁS DESTACADAS, SÓLO INGRESANDO TU CORREO ELECTRÓNICO

Hola amigos, este es video colaborativo entre varios canales de youtube de electrónica, la temática propuesta es el desarrollo de herramientas de laboratorio e instrumentos de medición, particularmente he creado un dispositivo que permite medir la corriente y potencia consumida por cualquier artefacto eléctrico que tengamos en nuestra hogar, oficina e industria.

Lo interesante de este dispositivo es que la medición de la corriente la podemos hacer sin tener que abrir el circuito, porque el sensor sct013-30 es muy similar a una pinza ampirométrica.

Hay que tener en cuenta que sólo se debe pasar uno de los cables para hacer la medición, porque si pasamos los dos conductores obtendremos una lectura errónea.

Circuito

El circuito es muy simple de montar, debemos montar el escudo ethernet arriba de un arduino uno, también podemos usar un arduino mega pero hay que hacer una leve modificación al código, por favor observar los comentarios en el código fuente, para ver que lineas se deben comentar y des comentar.

Vamos ha usar el display sh1106 para visualizar en todo momento la corriente consumida y la potencia. El LM358 es un amplificador operacional, cuya función es la rectificación de la onda alterna que genera el sensor sct-013-30, esta onda no es apta para el pin analógico A0 del arduino, porque este pin soporta tensiones que van desde 0 a 5 voltios y la tensión que puede entregar el sensor de corriente va de +/- 1 voltio.

El semi ciclo negativo puede dañar nuestro arduino, por lo que debemos eliminarlo, esto lo podríamos conseguir con diodos rectificadores pero los diodos de silicio provocan una caída de tensión de 0.7 voltios y los de germanio de 0.6 voltios, esto es demasiado para la señal que nos entrega el sensor de corriente sct0-013-30, así que vamos a usar un amplificador operacional el LM358 en su configuración como seguidor de tensión.

Cuya cofiguración es la siguiente

Y diagrama eléctrico es muy simple

Colocaremos una de  las puntas del osciloscopio en el pin 3 del LM358 y veremos una onda alterna que entrega el sensor de corriente, la otra punta va ir al pin 1 y 2 del amplificador operacional, ya podemos apreciar que se ha rectificado y sólo pasa el semi ciclo positivo, pero hay una parte de la onda que se pierde, esto no es problema porque el arduino mediante un calculo(teniendo en cuenta que la onda es simétrica) compensará esta falta de información, para lograr obtener los valores correctos de la corriente consumida por el artefacto a medir.

Como podemos observar en el circuito, el mismo arduino provee de alimentación de 5 voltios al amplificador operacional y al display oled.

Código fuente

El código está comentado en la mayoría de sus lineas, por favor leer detenidamente, para una fácil comprensión del mismo.

#include "U8glib.h"//libreriapara el control del display
#include "ThingSpeak.h"//Librería para subir datos a thingspeak
#define USE_ETHERNET_SHIELD//Definimos el uso de un escudo ethernet
#include <SPI.h>
#include <Ethernet.h>//Libreía para el control del escucudo ethernet
    byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};//dirección mac que vamos a usar con nuesctro escudo eth
    EthernetClient client;
// Inicializa la biblioteca del servidor Ethernet
// (el puerto 80 es el predeterminado para HTTP):
EthernetServer server(80);
U8GLIB_SH1106_128X64 u8g(U8G_I2C_OPT_NONE);  // I2C / TWI // Se habilita esta linea según el display a a usar en este caso el driver SH1106 
  float intencidad;//=corriente(); //Corriente eficaz (A)
  float sensor;
  float potencia;
unsigned long myChannelNumber = 1111111;//id del canal thingspeak
const char * myWriteAPIKey = "xxxxxxxxxxx";//key de escritura
unsigned long interval=15000; // Definimos el el tiempo que debemos esperar antes de subir un nuevo dato
unsigned long previousMillis=0;
long retardo2=millis();
//EthernetClient client;
void setup() {
  Serial.begin(9600);//velocidad de seteo del puerto serial
  analogReference(INTERNAL);//Configura la tensión de referencia utilizada para la entrada analógica 1.1 voltios
  //analogReference(INTERNAL1V1); //si usamos Arduino Mega
  Ethernet.begin(mac);//seta la dirección mac
  ThingSpeak.begin(client);
  Serial.println(Ethernet.localIP());//imprime la dirección ip obtenida por la placa eth
}
void loop() {
  float ondac=0;
  long retardo=millis();
  
  int s=0;
while(millis()-retardo<1000)//Duración de un segundo
  { 
//-------Ecuaciones para el calculo de la intencidad y potencia 
    sensor = analogRead(A0) * (1.115 / 1023.0);////voltaje del sensor(se puede cambiar el valor para lograr mayor presisción)
    intencidad=sensor*30.0; //corriente=sensor*(30A/1V)
    ondac=ondac+sq(intencidad);//Sumatoria de Cuadrados/ sq-->cuadrado de un número
    s=s+1;
    delay(1);
  }
  ondac=ondac*2;//Para compensar los cuadrados de los semiciclos negativos.
  intencidad=sqrt((ondac)/s); //ecuación del RMS sqrt-->raiz cuadrada
  potencia=intencidad*220.0; // P=IV (Watts) cualculo de la potencia
  Serial.print("Corriente: ");
  Serial.print(intencidad,4);
  Serial.print(" Amperes, Potencia: ");
  Serial.print(potencia,4);  
  Serial.println(" Watts");
//--------Sube los datos thinspeak.com-------------
unsigned long currentMillis = millis(); // grab current time 
//Compruebe si ha transcurrido el intervalo de 15 segundos
 if ((unsigned long)(currentMillis - previousMillis) >= interval) {
//Sube al canal de thinspeak el valor de la potencia  
ThingSpeak.writeField(myChannelNumber, 1, potencia, myWriteAPIKey);
   previousMillis = millis();
 }
 //----Crea un servidor web donde se muestra el valor de la intencidad y potencia cada 3 segundos---------
  EthernetClient client = server.available();
  if (client) {
    Serial.println("new client");
    boolean currentLineIsBlank = true;
    while (client.connected()) {
      if (client.available()) {
        char c = client.read();
        Serial.write(c);
        if (c == '\n' && currentLineIsBlank) {
          client.println("HTTP/1.1 200 OK");
          client.println("Content-Type: text/html");
          client.println("Connection: close");  // La conexión se cerrará una vez completada la respuesta
          client.println("Refresh: 3");  // Actualizar la página automáticamente cada 3 segundos
          client.println();
          client.println("<!DOCTYPE HTML>");
          client.println("<html>");
          client.print("Corriente: ");
          client.print(intencidad, 4);
          client.println(" Potencia: ");
          client.print(potencia, 4);
          client.println("<br />");
          client.println("</html>");
          break;
        }
        if (c == '\n') {
                    currentLineIsBlank = true;
        } else if (c != '\r') {
         
          currentLineIsBlank = false;
        }
      }
    }
     delay(1);
    client.stop();
    Serial.println("client disconnected");
  }
//--------Muestra en la pantalla los valores obtenidos de intencidad y potencia-----------------
    u8g.firstPage();  
  do {
    draw();//Llama a la función draw
  } while( u8g.nextPage() );
  // Reconstruir la imagen después de un tiempo
  delay(50);
}
void draw(void) {
  //Los comandos gráficos para volver a dibujar la pantalla completa deben colocarse aquí 
  u8g.setFont(u8g_font_unifont);
  u8g.setPrintPos(0, 20); 
  u8g.print("Int:");
  u8g.print(intencidad,4);
  u8g.print("A");
  u8g.setPrintPos(0, 40); 
  u8g.print("Pot:");
  u8g.print(potencia,4);
  u8g.print("W");
}

Recuerden que tienen que crear un canal en el cloud de www.thingspeak.com  donde obtendrán datos del Id del canal y la Api de escritura con estos datos ya pueden ir al código fuente y cambiar esos datos.

Materiales

Arduino uno

Podemos usar el arduino uno o el arduino mega, pero observen el código fuente poque hay que hacer una leve modificación, al mismo según el arduino a usar. Nuestro arduino es el cerebro de todo el proyecto es quien se encargará de tomar lecturas del sensor y procesar estas señales para poder verlas en el display, el terminal serial, el control del escudo ethernet, y proveerá de la alimentación a todo el circuito.

Escudo ethernet

Nuestro escudo ethernet será necesario, para subir datos a thingspeak.com y también para mostrar datos en nuestra red local, sólo debemos abrir algún navegador web y escribir la ip que allá asignado nuestro router, eso lo podemos ver en el terminal serial. Una de las mejoras que se hará a futuro es agregar esta información en el display.

Sensor SCT013-30

Este sensor nos permite realizar medidas en un rango de hasta 30A. Este modelo tiene una resistencia de carga interna( a diferencia del sct-013-100 que debemos agregarle un resistor de 20 ohm), entregándonos una salida de voltaje de +/-1 voltio. La relación es de 30A–>+/-1V

Transformador de corriente de núcleo dividido

SCT013

Especificaciones

SCT013-030V

Display Oled sh1106

Se trata de un módulo de pantalla OLED monocromática DE 128×64 puntos con interface I2C .Que presenta varias ventajas en comparación con pantallas LCD, y podemos destacar su alto brillo, un muy buen contraste, un ángulo de visión más amplio, y bajo consumo de energía. ES compatible con Arduino Rasberry Pi y micro controladores PIC entre otros. Trabaja con niveles lógicos de 3.3V a 5V tiene un angulo de visión mayor a los 160 grados. el Tamaño de la pantalla es de 1,3 pulgadas. Se alimenta con un voltaje de 3.3V a 5V Se lo puede usar en aplicaciones como relojes inteligentes, MP3, termómetros, instrumentos, y proyectos varios, etc.

Librería

U8glib

Características

Interface: I2C(3.3V / 5V logic level)

Resolution: 128 x 64

Angle of view: >160 degree

Display color: Blue

Display size: 1.3 inch

Driver IC: SH1106

Power supply: DC 3.3V~5V

Operating temperature: -20~70’C

Application: smart watch, MP3, thermometer, instruments, DIY projects, etc.

Amplificador operacional LM358

Características:

• • No. de amplificadores operacionales: 2
  • No requiere fuente dual (Sin embargo con fuente sencilla no es posible que la salida obtenga voltajes negativos)
  • Voltaje de alimentación: 3 V a 32 V fuente sencilla (±1.5 V a ±16 V fuente dual)
  • Bajo consumo de potencia
  • Ancho de banda típico: 0.7 MHz
  • Compensado en frecuencia internamente
  • Alta ganancia
  • Compatible con todas las formas de lógica
  • Encapsulado: DIP 8 pines

Hoja de datos

LM158-LM258-LM358_ST

LM158-LM158A-LM258-LM258A-LM358-LM358A-LM2904-LM2904V_TI

LM258-LM358-LM358A-LM2904-LM2904A-LM2904V-NCV2904-NCV2904V_ON

PinOut Lm358

Ficha jack hembra

Debemos conectar el sensor al circuito, lo haremos a travéz de esta ficha jack hembra de 3/5

Cables dupont

Para la inter conexión de todo el circuito, se puede cambiar por cable telefónico que es más económico

Protoboard

Power Bank

Es opcional se puede alimentar directamente de una pc(el circuito está totalmente aislado) o fuente externa

Cable Usb

Este cable cumple dos funciones una es la programación del arduino y la otra la alimentación del mismo

Cable de red

Sólo si necesitamos que nuestro proyecto se conecte a Internet o red de area local

El circuito trabaja muy bien, quizá debamos hacer algunos ajustes mínimos en el código fuente, como se explica en el video más arriba. Recomiendo probar distintas marcar de amplificadores operacionales, no con todos tuve los mejores resultados, todas formas es un circuito integrado muy económico, si está dentro de las posibilidades, comprar más de uno de distintas marcas e ir probando.

Lista completa con todos los proyectos presentadas por otros youtubers

Tal vez pueda interesarte proyectos en arduino, pic, robótica, telecomunicaciones, suscribete en http://www.youtube.com/user/carlosvolt?sub_confirmation=1 mucho videos con código fuentes completos y diagrama

SUSCRIBETE A NUESTROS BOLETINES, RECIBE EN TU CORREO LAS NOTICIAS MÁS DESTACADAS, SÓLO INGRESANDO TU CORREO ELECTRÓNICO

Saludos internautas en el nombre de rogerbit.com y CarlosVolt Tutoriales, en este proyecto vamos a construir un sistema de temperatura, el cual tiene un rango de aplicaciones muy amplias, desde el uso hobbysta, smarthome e inclusive aplicaciones comerciales e industriales.

Vamos a desarrollar un sistema completo de notificaciones de exceso de temperatura, mediante dos avisos uno sonoro con la ayuda de un buzzer y el otro mediante un llamado telefónico con el módulo sim900.

Tal vez pueda interesarte proyectos en arduino, pic, robótica, telecomunicaciones, suscribete en http://www.youtube.com/user/carlosvolt?sub_confirmation=1 mucho videos con código fuentes completos y diagrama

El sensor DS18B20 (18ds20) es un sensor muy popular en el mundo Maker, debido a su bajo precio, su amplio rango de temperatura  -55 a 125 ° C (-67 ° F a +257 ° F), pero quizá lo que lo hace más atractivo es el hecho que viene en un encapsulado metálico y es sumergible.

Este sensor a sido donado para mi canal por DFROBOT www.dfrobot.com

El funcionamiento del sistema es el siguiente, si se excede la temperatura (por ejemplo de 25 grados celsuis) el dispositivo activará una alerta sonoro mediante un buzzer, pero adicional mente hará un llamado telefónico a un número predeterminado, con el objetivo de avisar que se excedido la temperatura límite configurada.

Vamos a utilizar el arduino uno, quien se encargará de comandar todas alas acciones del proyecto, este leerá la temperatura enviada por el sensor y en base a ese valor hará sonar la alarma y cursará el llamado telefónico.

El módulo sim900 es un módulo GSM muy popular, este será nuestro módulo de comunicaciones y se montará encima del arduino uno, los pines 2 y 3 están reservados para el puerto virtual serial y los pines 0 y 1 el puerto serial por hardware. En el pin 4 se conectará el sensor de temperatura y el pin 5 está reservado para el buzzer.

Veamos el hardware que vamos a usar:

Kit de sensor impermeable DS18B20

INTRODUCCIÓN

Este sensor de temperatura a prueba de agua es el DS18B20. Este kit de sensor de temperatura impermeable utiliza la misma sonda – sonda DS18B20 AS. Contiene una sonda con un módulo resistivo. Así que es fácil de conectar en la placa Arduino.

El sensor de temperatura DS18B20 proporciona lecturas de temperatura de 9 a 12 bits (configurables) a través de una interfaz de 1 hilo, de modo que sólo se necesita conectar un cable (y tierra) desde un microprocesador central. Compatible con sistemas 3.0-5.5V.

ESPECIFICACIÓN

• Voltaje de funcionamiento: 3.0 ~ 5.5V
• ± 0,5 ° C Precisión de -10 ° C a + 85 ° C
• Rango de temperatura útil: -55 a 125 ° C (-67 ° F a +257 ° F)
• Resolución seleccionable de 9 a 12 bits
• Utiliza interfaz de 1 hilo, requiere sólo un pin digital para la comunicación
• ID único de 64 bits grabado en un chip
• Varios sensores pueden compartir un pin
• Sistema de alarma de límite de temperatura
• El tiempo de consulta es inferior a 750ms
• Interfaz de 3 hilos:
  • Tipo A
    • Cable rojo – VCC
    • Cable negro – GND
    • Cable amarillo – DATA
  • Tipo B
    • Cable rojo – VCC
    • Cable amarillo – GND
    • Cable verde – DATA
• Tubo de acero inoxidable de 6 mm de diámetro por 35 mm (1,34 “) de largo
• Diámetro del cable: 4mm (0.16 “)
• Longitud: 90cm (35.43 “)

Sim900

Este es un módulo gsm cuatri banda, con la posibilidad de realizar y recibir llamados telefónicos, pero también puede enviar y recibir mensajes de texto, y lograr una conexión a Internet, muy útil para enviar datos a un servidor, entra otras funciones que no voy a detallar.

Yo uso el módulo sim900 del fabricante epalsite, aunque muchos fabricantes y cada uno le agrega su toque personal y veces genera incompatibilidades con algunos códigos fuentes y toca hacer retoques para que pueden funcionar correctamente. Pero no deja de ser un buen módulo para proyecto M2M y para IOT.

Tiene una ranura para colocar un sim de nuestra operadora, se le puede colocar una pila para mantener la hora ya que posee un rtc(real time clock) un reloj interno, y también un lector de memorias micro sd, por si necesitamos almacenar datos en una memoria micro sd, soporta comandos at.

Especificaciones Sim900

SIM900 Features

• Quad-Band 850/ 900/ 1800/ 1900 MHz
• Low power consumption: 1.0mA(sleep mode&BS-PAMFRMS=9)
• Operation temperature: -40°C to +85 °C
• GPRS class 10: max. 85.6 kbps (downlink)
• Embedded TCP/UDP protocol
• RTC backup
• PWM
• ADC

 Features of this shield

• Compatible with Arduino
• SD card slot, can be disabled by the jumper
• Two in one Earphone Socket
• Software and Hardware Serial port:Can communicate with Arduino through the Software serial port(D2/D3)or the Hardware serial port(D0/D1)
• FTDI interface. You can use the PC or other host which have an USB port(through FT232RL board) to debug it.
• Battery slot for RTC. This is useful if you want the time of the module doesn’t lose when it is Power Off.
• Software or Hardware Power ON/OFF. You can Power On/Off SIM900 through an IO of Arduino or the “PWRKEY” button on the board.

Hoja de datos–> Sim900_datasheet

Sitio del fabricante http://wiki.epalsite.com/index.php?title=SIM900_Quad-Band_GPRS_shield_with_Micro_SD_card_slot

Arduino Uno

El pinout del arduino uno es totalmente compatible con el arduino uno, así que se puede acoplar directamente el sim900 sin ningún inconveniente de compatibilidad. El sim900 utlizado en este proyecto utiliza los pines 2 y 3 para la comunicación el arduino uno, aunque tiene unos jumper que permiten utilizar los pines 0 y 1 del arduino si se requiere.

Buzzer

El buzzer se alimenta con 5 voltios, pero recuerden que tiene polaridad

Código Fuente

//Suscribete en http://www.youtube.com/user/carlosvolt?sub_confirmation=1
//Grupo en Facebook https://www.facebook.com/groups/RogerBit/
#include <SoftwareSerial.h>//Crea un puerto serial virtual por software
SoftwareSerial  Sim900Serial(2, 3);//El pin 2 y 3 seran utilizados para rx y tx
// Incluya las bibliotecas que necesitamos para controlar el sensor ds18b20
#include <OneWire.h>
#include <DallasTemperature.h>
// El cable de datos está conectado al puerto 4 del Arduino
#define ONE_WIRE_BUS 4
//Configure una instancia oneWire para comunicarse con cualquier dispositivo OneWire
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);
//Declaración de variables
float temperatura=0.00;
int i=0;
unsigned long numero=xxxxxxxxx;//Calocar el número de telefono al que se quiere llamar
void setup()
{
pinMode(5, OUTPUT);
Sim900Serial.begin(19200);               // velocidad de transmisión SIM900   
  Serial.begin(19200);             // velocidad de transmisión del arduino
    sensors.begin();//Inicializamos el sensor
  delay(500);
}
void loop()
{
  grados();
//Si la temepratura es mayor a 25
if(temperatura>25.00){
Sim900Serial.print("ATD"); //ATD es un comando para hacer llamados de voz
Sim900Serial.print(numero);//Al numero que se quiere llamar 
Sim900Serial.println(";");//Comando ATD para llamar a un número telefonico es importante el ";"
delay(1000);
Serial.println("Llamando...");//Se imprime la leyenda Llamando...
  while(i<=20){//Se repite 20 veces
  delay(850);//Retardo de un segundo
  //Hace zonar un buzzer durante 20 segundos
 digitalWrite(5, HIGH);
   delay(150);
   digitalWrite(5, LOW); 
   i++;//Incrementamos i de a uno hasta que no se cumpla la condición
      grados();
 }
 //Corta la llamado después de un tiempo
 if(i>1){
  Sim900Serial.println("ATH");//ATH es un comando AT para cortar el llamado
Serial.println("Corte de llamada");//Se imprime en el terminal serial "Corte llamado"
i=0;
 //Esperamos 2 minutos antes de un nuevo llamado
  while(i<120){//Se repite 120 veces
  delay(1000);//Retardo de un segundo
   i++;//Incrementamos d de a uno hasta que no se cumpla la condición
   Serial.print("Listo para llamar en 120 segundos, trancurridos: ");
   Serial.println(i);
   grados();
}
i=0;
  }  
 }
}
void grados(){
sensors.requestTemperatures(); // Envía el comando para obtener temperaturas
  temperatura=sensors.getTempCByIndex(0);/// getTempCByIndex(0) se refiere al primer 
  //sensor si es que tubieramos más de uno conectado en el cable
  Serial.print("La temperatura es: ");
  Serial.print(temperatura);//Imprime la temperatura
  Serial.println(" Grados centigrados");
}

Bueno esto es todo amigos, recomiendo ver el video donde podrán ver como conectar todo el harware en un par de minutos, si quieren comprar el sensor con su interface lo pueden hacer en el siguiente link Waterproof DS18B20 Sensor Kit

Este proyecto no hubiese sido posible sin el apoyo de DFROBOT

Lo mejor está por venir…

Romeo – an Arduino Robot Control Board with Motor Driver

Gravity: Analog High Temperature Sensor

Beetle BLE – The smallest Arduino bluetooth 4.0 (BLE)

Tal vez pueda interesarte proyectos en arduino, pic, robótica, telecomunicaciones, suscribete en http://www.youtube.com/user/carlosvolt?sub_confirmation=1 mucho videos con código fuentes completos y diagrama

SUSCRIBETE A NUESTROS BOLETINES, RECIBE EN TU CORREO LAS NOTICIAS MÁS DESTACADAS, SÓLO INGRESANDO TU CORREO ELECTRÓNICO

Muy buenas, en otra revisión de hoy veremos el módulo Bluetooth 4.0 Bluno Beetle Ble de la empresa DFROBOT, un interesante dispositivo con el que podremos darle vida a nuestros proyectos, en un tamaño muy compacto y con bajo consumo de energía, sin duda algo que encanta en el mundo Maker.

Por otro lada ademas de integrar Bluetooth 4.0 tambien viene con un arduino uno, con menos pines por supuesto, pero en un tamaño muy reducido que nos recuerda al de una tarjeta SD.

Tal vez pueda interesarte proyectos en arduino, pic, robótica, telecomunicaciones, suscribete en http://www.youtube.com/user/carlosvolt?sub_confirmation=1 mucho videos con código fuentes completos y diagrama

¿Que es el Bluno Beetle Ble?

El Beetle Ble,  es una placa Arduino Uno con bluetooth 4.0 (BLE). Es probablemente la placa Arduino BLE más pequeño en el mercado. Utiliza IDE estándar de Arduino para cargar códigos sin necesidad de biblioteca y controladores adicionales. Este Beetle BLE es otro hito en la línea Beetle, lo que hace que los usuarios de bricolaje tengan más opciones en el diseño del proyecto. Es totalmente compatible con  Bluno  en instrucciones y procedimientos. Soporta los modos Bluetooth HID e ibeacon.

El Beetle BLE ofrece un super pequeño y de bajo costo Arduino con bluetooth 4.0. El Beetle BLE se puede utilizar para proyectos, tales como bricolaje, talleres, wearable E-Textiles y educativo. Para los estudiantes y los fabricantes que no pueden permitirse demasiado en la compra de hardware, Beetle puede ser una gran solución.

Al igual que una placa Arduino nativa , pero con Bluetooth 4.0. Un APP llamado Play Bluno está disponible en IOS y Android, lo que da un acceso rápido a este pequeña placa.

No sólo soporta la programación USB, sino también el método de carga inalámbrica.

CARACTERISTICAS

• ATmega328 @ 16MHz
• Bluetooth baja energía (BT 4.0)
• Puerto micro USB
• Tamaño Super Compacto
• Soporta Bluetooth HID e ibeacon
• Comaptible con todas las series Bluno de DFRobot
• Soporte de programación inalámbrica

ESPECIFICACIÓN

• Chip Bluetooth: CC2540
• Sensibilidad: -93dBm
• Temperatura de trabajo: -10 ℃ ~ +85 ℃
• Distancia máxima: 50m (1968.50 “) (campo abierto)
• Microcontrolador: ATmega328
• Frecuencia de reloj: 16 MHz
• Tensión de funcionamiento: 5V DC
• Voltaje de entrada: <8V (Vin <8V)
• Pin digital x4
• Pin analógico x4
• Salida PWM x2
• Interfaz UART x1
• Interfaz I2C x1
• Interfaz micro USB x1
• Puerto de alimentación x2
• Tamaño: 28.8mm X 33.1mm (1.13 “x 1.30”)
• Peso: 10g

Lista de Materiales

Bluno Beetle Ble

Módulo receptor infrarrojo, con el cual capturaremos los códigos del control remoto

Sensor TSOP1838

Resistor 330 ohm

Transistor NPN BC548

Diodo emisor infrarrojo

Lo primero que debemos hacer es subir el siguiente skecht, al beetle ble, con este ejemplo vamos a capturar los códigos del control remoto que queremos clonar, recordemos que el ejemplo por defecto utiliza el pin número 11 el cual el beetle ble no posee pero simplemente cambiamos por el pin número 5, y este problema ya está solucionado

Abrimos el terminal serial, apretamos el botón del control que queremos capturar, ahora observaremos algo parecido a lo siguiente

La información que nos interesa es el Encoding en este ejemplo el RC5, el code el número 820 y los bits que son 12 para el ejemplo que se muestra.

Código fuente para capturar códigos del control remoto

//------------------------------------------------------------------------------
// Include the IRremote library header
//
#include <IRremote.h>

//------------------------------------------------------------------------------
// Tell IRremote which Arduino pin is connected to the IR Receiver (TSOP4838)
//
int recvPin = 5;
IRrecv irrecv(recvPin);

//+=============================================================================
// Configure the Arduino
//
void  setup ( )
{
  Serial.begin(9600);   // Status message will be sent to PC at 9600 baud
  irrecv.enableIRIn();  // Start the receiver
}

//+=============================================================================
// Display IR code
//
void  ircode (decode_results *results)
{
  // Panasonic has an Address
  if (results->decode_type == PANASONIC) {
    Serial.print(results->address, HEX);
    Serial.print(":");
  }

  // Print Code
  Serial.print(results->value, HEX);
}

//+=============================================================================
// Display encoding type
//
void  encoding (decode_results *results)
{
  switch (results->decode_type) {
    default:
    case UNKNOWN:      Serial.print("UNKNOWN");       break ;
    case NEC:          Serial.print("NEC");           break ;
    case SONY:         Serial.print("SONY");          break ;
    case RC5:          Serial.print("RC5");           break ;
    case RC6:          Serial.print("RC6");           break ;
    case DISH:         Serial.print("DISH");          break ;
    case SHARP:        Serial.print("SHARP");         break ;
    case JVC:          Serial.print("JVC");           break ;
    case SANYO:        Serial.print("SANYO");         break ;
    case MITSUBISHI:   Serial.print("MITSUBISHI");    break ;
    case SAMSUNG:      Serial.print("SAMSUNG");       break ;
    case LG:           Serial.print("LG");            break ;
    case WHYNTER:      Serial.print("WHYNTER");       break ;
    case AIWA_RC_T501: Serial.print("AIWA_RC_T501");  break ;
    case PANASONIC:    Serial.print("PANASONIC");     break ;
    case DENON:        Serial.print("Denon");         break ;
  }
}

//+=============================================================================
// Dump out the decode_results structure.
//
void  dumpInfo (decode_results *results)
{
  // Check if the buffer overflowed
  if (results->overflow) {
    Serial.println("IR code too long. Edit IRremoteInt.h and increase RAWLEN");
    return;
  }

  // Show Encoding standard
  Serial.print("Encoding  : ");
  encoding(results);
  Serial.println("");

  // Show Code & length
  Serial.print("Code      : ");
  ircode(results);
  Serial.print(" (");
  Serial.print(results->bits, DEC);
  Serial.println(" bits)");
}

//+=============================================================================
// Dump out the decode_results structure.
//
void  dumpRaw (decode_results *results)
{
  // Print Raw data
  Serial.print("Timing[");
  Serial.print(results->rawlen-1, DEC);
  Serial.println("]: ");

  for (int i = 1;  i < results->rawlen;  i++) {
    unsigned long  x = results->rawbuf[i] * USECPERTICK;
    if (!(i & 1)) {  // even
      Serial.print("-");
      if (x < 1000)  Serial.print(" ") ;
      if (x < 100)   Serial.print(" ") ;
      Serial.print(x, DEC);
    } else {  // odd
      Serial.print("     ");
      Serial.print("+");
      if (x < 1000)  Serial.print(" ") ;
      if (x < 100)   Serial.print(" ") ;
      Serial.print(x, DEC);
      if (i < results->rawlen-1) Serial.print(", "); //',' not needed for last one
    }
    if (!(i % 8))  Serial.println("");
  }
  Serial.println("");                    // Newline
}

//+=============================================================================
// Dump out the decode_results structure.
//
void  dumpCode (decode_results *results)
{
  // Start declaration
  Serial.print("unsigned int  ");          // variable type
  Serial.print("rawData[");                // array name
  Serial.print(results->rawlen - 1, DEC);  // array size
  Serial.print("] = {");                   // Start declaration

  // Dump data
  for (int i = 1;  i < results->rawlen;  i++) {
    Serial.print(results->rawbuf[i] * USECPERTICK, DEC);
    if ( i < results->rawlen-1 ) Serial.print(","); // ',' not needed on last one
    if (!(i & 1))  Serial.print(" ");
  }

  // End declaration
  Serial.print("};");  // 

  // Comment
  Serial.print("  // ");
  encoding(results);
  Serial.print(" ");
  ircode(results);

  // Newline
  Serial.println("");

  // Now dump "known" codes
  if (results->decode_type != UNKNOWN) {

    // Some protocols have an address
    if (results->decode_type == PANASONIC) {
      Serial.print("unsigned int  addr = 0x");
      Serial.print(results->address, HEX);
      Serial.println(";");
    }

    // All protocols have data
    Serial.print("unsigned int  data = 0x");
    Serial.print(results->value, HEX);
    Serial.println(";");
  }
}

//+=============================================================================
// The repeating section of the code
//
void  loop ( )
{
  decode_results  results;        // Somewhere to store the results

  if (irrecv.decode(&results)) {  // Grab an IR code
    dumpInfo(&results);           // Output the results
    dumpRaw(&results);            // Output the results in RAW format
    dumpCode(&results);           // Output the results as source code
    Serial.println("");           // Blank line between entries
    irrecv.resume();              // Prepare for the next value
  }
}

Con este código vamos a enviar el código capturado, hay que tener en cuanta que esta librería no soporta todos los controles remotos que existen.

#include <IRremote.h>//Librería para controles remotos infrarrojos
IRsend irsend;
//Variables
char a;
int led13=13;
int i=0;
void setup() {
  pinMode(led13, OUTPUT);//Led 13 como salida para generar un destello
  Serial.begin(115200);  //Velocidad del puerto serial
}
void loop() {
//Leemos los caracteres que ingresan al puerto serial
  if (Serial.available())  {
    a=Serial.read();//Le asignamos a la variable "a" el caracter leido del puerto serial
    Serial.write(a);//Reenviamos el mismo valor al puerto serial
    Serial.println();   //Enviamos el caracter de nueva linea
//-----canal arriba-------
  if(a=='a'){
     digitalWrite(led13, HIGH);   //Enciende el led al enviar un comando al televisor
     if(i==0){
     irsend.sendRC5(0x820, 12);//Código para cambiar el canal
     i=1;
     }
     if(i==1){
     irsend.sendRC5(0x20, 12);//En esta caso si se vuelve a paretar el mismo botón envía este código
     i=0;
     }
     delay(200);
     digitalWrite(led13, LOW);//Apaga el led
    }
//-----canal abajo-------    
  if(a=='b'){
     digitalWrite(led13, HIGH);   
      if(i==0){
     irsend.sendRC5(0x821, 12);
     i=1;
     }
     if(i==1){
     irsend.sendRC5(0x21, 12);
     i=0;
     }
     delay(200);
     digitalWrite(led13, LOW);
    }
//-----Subir volumen------    
  if(a=='c'){
     digitalWrite(led13, HIGH);  
     if(i==0){
     irsend.sendRC5(0x810, 12);
     i=1;
     }
     if(i==1){
     irsend.sendRC5(0x10, 12);
     i=0;
     }
     delay(200);
     digitalWrite(led13, LOW);
    }
//-----Bajar volumen-----    
      if(a=='d'){
     digitalWrite(led13, HIGH);   
     if(i==0){
     irsend.sendRC5(0x811, 12);
     i=1;
     }
     if(i==1){
     irsend.sendRC5(0x11, 12);
     i=0;
     }
     delay(200);
     digitalWrite(led13, LOW);
    }                
  }
}

Bluno Basic Demo

Bluno Basic Demo es una aplicación desarrollada por DFROBOT  y está para descargar para Andrioid y IOS, es de código abierto, así qu e podemos adaptarla a nuestras necesidades y gustos.

Esta aplicación escanea en busca de nuestro Bluno, y una vez que nos aparezca lo seleccionamos, y en el caso de que nunca hubiésemos puesto la contraseña la misma por defecto es 000000 (seis ceros),  esta puede ser modificada por comandos At de ser necesario.

Para descargar la aplicación Android puedes hacerlo de aquí BlunoBasicDemo

Y para IOS debes compilar el código para descargarlo https://github.com/DFRobot/BlunoBasicDemo/tree/master/IOS/BlunoBasicDemo

Nota importante: No todos los celulares, tables y pc soporta bluetooth 4.0, esto hay que tenerlo en cuenta y ver las características del dispositivo que vamos a usar, antes de probar, si no estaremos perdiendo el tiempo.

Armado del circuito

La conexión del circuito es muy simple, el pin número 5 del Bluno Beetle se conecta al pin de señal de modulo Sensor TSOP1838, este módulo se alimenta con 5 voltios obtenidos del mismo Bluno. El pin 3 del bluno va conectado a un resistor de 330 ohm, el cual se conecta a la base del transistor BC548, el colector se conecta directamente a 5 voltios del bluno, el emisor va conectado al ánodo del diodo emisor infrarrojo y cátodo de este diodo a tierra

Pint Out

Atención la contraseña por defecto del Bluno Beetle Ble es 000000

Circuito

Puedes comprar a Bluno Blettle Ble en este link

Para más información visita la página de DFRobot con su Wiki

Tal vez pueda interesarte proyectos en arduino, pic, robótica, telecomunicaciones, suscribete en http://www.youtube.com/user/carlosvolt?sub_confirmation=1 mucho videos con código fuentes completos y diagrama

SUSCRIBETE A NUESTROS BOLETINES, RECIBE EN TU CORREO LAS NOTICIAS MÁS DESTACADAS, SÓLO INGRESANDO TU CORREO ELECTRÓNICO

VIDEO RECOMENDADO

El sensor PT100, es un sensor detector de temperatura resistivo o RTD, el cual varía sus resistencia en función de la temperatura.

Para su construcción se utiliza el platino, porque tiene la particularidad de tener una relación resistencia- temperatura sumamente lineal, por lo que es el material más utilizado.

El sensor PT100, tiene una resistencia eléctrica de 100 ohm a una temperatura de 0 grados.

La termo-resistencia PT100, se usan normalmente para aplicaciones industriales o de laboratorio.

Tal vez pueda interesarte proyectos en arduino, pic, robótica, telecomunicaciones, suscribete en http://www.youtube.com/user/carlosvolt?sub_confirmation=1 mucho videos con código fuentes completos y diagrama

Especificación

Módulo

• Voltaje de trabajo: 3.3V-5.5V
• Tensión de salida analógica: 0.2V-2.8V
• Gama de temperatura de trabajo: 30-350 centígrados
• Error relativo: ± 2% FS
• Interfaz: PH2.0-3P
• Tamaño: 42mm * 32mm * 18mm
• no impermeable

Sonda PT100

• Temperatura de trabajo de la sonda: -20 – 400 centígrados
• La temperatura más alta de la piel: 200 centígrados
• Longitud: 2m
• Precisión: 0.5 centígrados
• Impermeable

Descripción de la placa

LABEL NAME Function Description 1 PT100- PT100- 2 PT100- PT100- 3 PT100+ PT100+ 4 Signal Output Signal Output 5 VCC Power Input +(3.3V-5.5V) 6 GND GND

• Hardware
  • Compatible con DFRduino UNO  o Arduino x1
  • Sensor del sensor de temperatura PT100 x1
  • módulo sensor de alta temperatura x1
  • PH2.0-3P cable x1
• Software
  • Arduino IDE V1.6.5 o superior Haga clic para descargar Arduino IDE de Arduino®
  • Librería HighTemperatureSensor DFRobotHighTemperatureSensor

Display Oled sh1106

Se trata de un módulo de pantalla OLED monocromática DE 128×64 puntos con interface I2C .Que presenta varias ventajas en comparación con pantallas LCD, y podemos destacar su alto brillo, un muy buen contraste, un ángulo de visión más amplio, y bajo consumo de energía. ES compatible con Arduino Rasberry Pi y micro controladores PIC entre otros. Trabaja con niveles lógicos de 3.3V a 5V tiene un angulo de visión mayor a los 160 grados. el Tamaño de la pantalla es de 1,3 pulgadas. Se alimenta con un voltaje de 3.3V a 5V Se lo puede usar en aplicaciones como relojes inteligentes, MP3, termómetros, instrumentos, y proyectos varios, etc.

 

Librería

U8glib

---

Características

Interface: I2C(3.3V / 5V logic level)

Resolution: 128 x 64

Angle of view: >160 degree

Display color: Blue

Display size: 1.3 inch

Driver IC: SH1106

Power supply: DC 3.3V~5V

Operating temperature: -20~70’C

Application: smart watch, MP3, thermometer, instruments, DIY projects, etc.

Código fuente

Con este código podremos visualizar la temperatura obtenida en un display oled

//
#include<DFRobotHighTemperatureSensor.h>//Librería para obtener el valor de la temperatura del sensor
#include "U8glib.h"//libreriapara el control del display
const float voltageRef = 5.000;       //Fije el voltaje de la referencia
//const float voltageRef = 3.300;
U8GLIB_SH1106_128X64 u8g(U8G_I2C_OPT_NONE);  // I2C / TWI // Se habilita esta linea según el display a a usar en este caso el driver SH1106     
int HighTemperaturePin = A0;	//Setting pin
int temperatura;
DFRobotHighTemperature PT100 = DFRobotHighTemperature(voltageRef); //Define un objeto PT100

void setup(void) {
  Serial.begin(9600);//Velocidad del puerto serial
}

void loop(void) {
  temperature = PT100.readTemperature(HighTemperaturePin);  //Obtenemos la temperatura
  Serial.print("temperatura:  ");
  Serial.print(temperatura);
  Serial.println("  ^C");
  delay(1000); //Se lee el valor de la temperatura cada un segundo
  //--------Muestra en la pantalla el valor obtenido de temepratura-----------------
    u8g.firstPage();  
  do {
    draw();//Llama a la función draw
  } while( u8g.nextPage() );
  // Reconstruir la imagen después de un tiempo
  delay(50);
}

void draw(void) {
  //Imprimimos en pantalla el valor de la temperatura obtenida
  u8g.setFont(u8g_font_unifont);
  u8g.setPrintPos(0, 20); 
  u8g.print("Temperat:");
  u8g.print(temperatura);
  u8g.print("^C");
  }

Puedes comprar este sensor con el módulo en la página de Gravity: Sensor analógico de alta temperatura

Tal vez pueda interesarte proyectos en arduino, pic, robótica, telecomunicaciones, suscribete en http://www.youtube.com/user/carlosvolt?sub_confirmation=1 mucho videos con código fuentes completos y diagrama

SUSCRIBETE A NUESTROS BOLETINES, RECIBE EN TU CORREO LAS NOTICIAS MÁS DESTACADAS, SÓLO INGRESANDO TU CORREO ELECTRÓNICO

Que tal amigos, siguiendo con la revisiones de placas y sensores, con el aporte de la empresa DFRobot, hoy veremos una placa con prestaciones muy interesante, y es ideal para el desarrollo de prototipos robóticos  y el control de motores y servos, de una manera simple de conectar, porque la placa posee los driver para el control y potencia de estos.

¿Que es Arduino Romeo?

//

char msgs[5][15] = {
  "Right Key OK ", 
  "Up Key OK    ", 
  "Down Key OK  ", 
  "Left Key OK  ", 
  "Select Key OK" };
char start_msg[15] = {
  "Start loop "};                    
int  adc_key_val[5] ={
  30, 150, 360, 535, 760 };
int NUM_KEYS = 5;
int adc_key_in;
int key=-1;
int oldkey=-1;
void setup() { 
  pinMode(13, OUTPUT);  //we'll use the debug LED to output a heartbeat
  Serial.begin(9600);

  /* Print that we made it here */
  Serial.println(start_msg); 
}

void loop() 
{
  adc_key_in = analogRead(7);    // read the value from the sensor  
  digitalWrite(13, HIGH);
  /* get the key */
  key = get_key(adc_key_in);    // convert into key press
  if (key != oldkey) {   // if keypress is detected
    delay(50);      // wait for debounce time
    adc_key_in = analogRead(7);    // read the value from the sensor  
    key = get_key(adc_key_in);    // convert into key press
    if (key != oldkey) {         
      oldkey = key;
      if (key >=0){
        Serial.println(adc_key_in, DEC);
        Serial.println(msgs[key]);
      }
    }
  }
  digitalWrite(13, LOW);
}
// Convert ADC value to key number
int get_key(unsigned int input)
{   
  int k;
  for (k = 0; k < NUM_KEYS; k++)
  {
    if (input < adc_key_val[k])
    {  
      return k;  
    }
  }
  if (k >= NUM_KEYS)
    k = -1;     // No valid key pressed
  return k;
}

//Standard PWM DC control
int E1 = 5;     //M1 Speed Control
int E2 = 6;     //M2 Speed Control
int M1 = 4;    //M1 Direction Control
int M2 = 7;    //M1 Direction Control

///For previous Romeo, please use these pins.
//int E1 = 6;     //M1 Speed Control
//int E2 = 9;     //M2 Speed Control
//int M1 = 7;    //M1 Direction Control
//int M2 = 8;    //M1 Direction Control


void stop(void)                    //Stop
{
  digitalWrite(E1,LOW);   
  digitalWrite(E2,LOW);      
}   
void advance(char a,char b)          //Move forward
{
  analogWrite (E1,a);      //PWM Speed Control
  digitalWrite(M1,HIGH);    
  analogWrite (E2,b);    
  digitalWrite(M2,HIGH);
}  
void back_off (char a,char b)          //Move backward
{
  analogWrite (E1,a);
  digitalWrite(M1,LOW);   
  analogWrite (E2,b);    
  digitalWrite(M2,LOW);
}
void turn_L (char a,char b)             //Turn Left
{
  analogWrite (E1,a);
  digitalWrite(M1,LOW);    
  analogWrite (E2,b);    
  digitalWrite(M2,HIGH);
}
void turn_R (char a,char b)             //Turn Right
{
  analogWrite (E1,a);
  digitalWrite(M1,HIGH);    
  analogWrite (E2,b);    
  digitalWrite(M2,LOW);
}
void setup(void) 
{ 
  int i;
  for(i=4;i<=7;i++)
    pinMode(i, OUTPUT);  
  Serial.begin(19200);      //Set Baud Rate
  Serial.println("Run keyboard control");
} 
void loop(void) 
{
  if(Serial.available()){
    char val = Serial.read();
    if(val != -1)
    {
      switch(val)
      {
      case 'w'://Move Forward
        advance (255,255);   //move forward in max speed
        break;
      case 's'://Move Backward
        back_off (255,255);   //move back in max speed
        break;
      case 'a'://Turn Left
        turn_L (100,100);
        break;       
      case 'd'://Turn Right
        turn_R (100,100);
        break;
      case 'z':
        Serial.println("Hello");
        break;
      case 'x':
        stop();
        break;
      }
    }
    else stop();  
  }
}

//Standard DLL Speed control

int E1 = 4;     //M1 Speed Control
int E2 = 7;     //M2 Speed Control
int M1 = 5;    //M1 Direction Control
int M2 = 6;    //M1 Direction Control

///For previous Romeo, please use these pins.
//int E1 = 6;     //M1 Speed Control
//int E2 = 9;     //M2 Speed Control
//int M1 = 7;    //M1 Direction Control
//int M2 = 8;    //M1 Direction Control

//When m1p/m2p is 127, it stops the motor
//when m1p/m2p is 255, it gives the maximum speed for one direction
//When m1p/m2p is 0, it gives the maximum speed for reverse direction

void DriveMotorP(byte m1p, byte m2p)//Drive Motor Power Mode
{

  digitalWrite(E1, HIGH);
  analogWrite(M1, (m1p)); 

  digitalWrite(E2, HIGH);
  analogWrite(M2, (m2p)); 

}

void setup(void) 
{ 
  int i;
  for(i=6;i<=9;i++)
    pinMode(i, OUTPUT);  
  Serial.begin(19200);      //Set Baud Rate
} 
void loop(void) 
{ 
  if(Serial.available()){
    char val = Serial.read();
    if(val!=-1)
    {
      switch(val)
      {
      case 'w'://Move Forward
        DriveMotorP(0xff,0xff); // Max speed
        break;
      case 'x'://Move Backward
        DriveMotorP(0x00,0x00);
        ; // Max speed
        break;
      case 's'://Stop
        DriveMotorP(0x7f,0x7f);
        break;       

      }
    }
  }
}

int analogo0 = A0;//pin analógico utilizado para conectar el potenciómetro
int analogo1 = A1;
int val0;//variable para leer el valor del pin analógico
int val1;
int led13=13;
int E1 = 5;     //M1 Speed Control
int E2 = 6;     //M2 Speed Control
int M1 = 4;    //M1 Direction Control
int M2 = 7;    //M1 Direction Control
void setup()
{
Serial.begin(19200);
pinMode(led13, OUTPUT);
}
 
void loop()
{
val0 = analogRead(analogo0);//lee el valor del potenciómetro (valor entre 0 y 1023)
val1 = analogRead(analogo1);
Serial.print("Pin analogico 0: ");
Serial.println(val0);
Serial.print("Pin analogico 1: ");
Serial.println(val1);
if(val0>350){
digitalWrite(led13, HIGH); 
analogWrite (E1,255);
  digitalWrite(M1,LOW); 
  }
  else {
    analogWrite (E1,0);
  digitalWrite(M1,LOW);
 digitalWrite(led13, LOW);     
    }
///
if(val1>350){
digitalWrite(led13, HIGH); 
analogWrite (E2,255);
digitalWrite(M2,LOW); 
  }
  else {
analogWrite (E2,0);
digitalWrite(M2,LOW);
 digitalWrite(led13, LOW);     
    }    
delay(100);//espera el servo para llegar a la posición
}

Que tal adictos a los dispositivos IoT, hoy tengo el gusto de mostrarles una de las mejores placas para interenet de las cosas que he usado, y no sólo por su valor de 7.5 dolares en la versión normal o los 9 dolares en las versión plus, sino porque se combinan en una pequeña tarjeta, varias cosas interesantes, entre ellas soporta para wifi, configuración fácil mediante un webser muy intuitivo, posibilidad de expansiones, como la Arduino Dock 2, entre muchas otas expansiones. Quizá sea la velocidad a la que corre su procesador de 580 Mhz, o tener integrada un lector de tarjetas micro SD(versión plus unicamente), o hasta los 32 MB que tiene de memoria interna como una suerte de disco de almacenamiento, pero pienso que lo mejor es su sistema operativo Linux.

Nacida ya hace un tiempo, en una campaña de kicstater(tambien indiegogo) cuya meta en un inicio era de 15000 dólares y por cierto superando este limite de financiación en 672.801, se puede decir que su campaña fue un éxito rotundo.

Tal vez pueda interesarte proyectos en arduino, pic, robótica, telecomunicaciones, suscribete en http://www.youtube.com/user/carlosvolt?sub_confirmation=1 muchos videos con código fuentes completos y diagramas

Características

¿Pero que nos pueden decir los creadores del omega 2?

Presentamos Omega2, una computadora IoT.

¿Qué diablos es una computadora IoT ? Es una computadora Linux diseñada específicamente para la construcción de aplicaciones de hardware conectado. Combina el factor de tamaño pequeño y la eficiencia energética del Arduino, con la potencia y la flexibilidad del Raspberry Pi.

• El Omega2 es simple, incluso para las personas que recién están empezando a construir hardware.

Con Omega2, queremos reducir la barrera de entrada y permitir que todos den el salto al desarrollo de hardware.

Hicimos que el Omega2 sea muy pequeño para que se ajuste fácilmente a su proyecto de bricolaje o producto comercial. Tiene menos de 1/4 del tamaño de Raspberry Pi y menos de 1/3 del tamaño de Arduino Uno.

El Omega2 tiene Wi-Fi integrado y almacenamiento flash a bordo. Esto significa que cobra vida en el momento en que lo enciende. No tiene que preocuparse por comprar dongles Wi-Fi o instalar imágenes del sistema operativo en tarjetas SD externas.

El omega 2 corre aplicaciones

Usar Omega2 es como usar una computadora de escritorio. Hemos creado aplicaciones simples e intuitivas para que interactúes con Omega2. ¡También tenemos una App Store donde puedes descubrir aún más aplicaciones! Para los más aventureros, incluso puedes crear aplicaciones con nuestro SDK y publicarlas en la App Store de Onion para compartir con el mundo :)

El Omega 2 es una computadora Linux completa

No se deje engañar por su tamaño, el Omega2 es una computadora completa con Linux, el mismo sistema operativo que alimenta algunas de las infraestructuras de misión crítica más importantes del mundo. Puede pensar en Omega2 como un pequeño servidor Linux con Wi-Fi. (Sí, ¡incluso ejecuta Apache!)

Para los fanáticos de BSD, Omega2 también ejecuta FreeBSD.

Omega 2 habla varios idiomas de programación

Una ventaja importante de ejecutar Linux es que el Omega2 se puede programar con el lenguaje que desee. Ahorre tiempo utilizando idiomas y bibliotecas con los que ya está familiarizado.

El omega 2 esta integrado con el cloud de onion

El Omega2 se integra perfectamente con la nube de cebolla. Esto le permite controlarlo a distancia desde cualquier parte del mundo con nuestra UI web intuitiva o API RESTful. También puede ver el estado de su Omega2 en tiempo real e implementar actualizaciones de software cuando está en el campo.

Es modular

El Omega2 es fácilmente expandible. Hemos diseñado una gran cantidad de expansiones para que pueda agregar capacidades a través de un simple plug-and-play

Omega 2 es compatible con Arduino

El Omega2 se puede agregar fácilmente a sus proyectos Arduino existentes. Hemos diseñado un Dock Arduino para que pueda utilizar sus escudos Arduino existentes.

Pin Out de Omega 2

Arduino Dock R2

Arduino Dock R2 es un Arduino Uno completo que le permite a su Omega2 controlar el chip Arduino a través de una conexión en serie. Te permite utilizar todos tus Arduino Shields existentes y puedes programarlos con Arduino IDE, ¡como cualquier otro Arduino! También hemos roto los GPIO de Omega2, por lo que puedes usar Expansions con Arduino Dock R2 una vez que sueldas los encabezados.

Expansión Relay

La Relay de Expansion viene con dos relés para que pueda controlar las luces u otras señales eléctricas con Omega2. Los relés están clasificados para 2A a 240V.

Expansión OLED

La expansión OLED agrega una pantalla OLED monocroma de 128×64 al Omega2. Puede usar la pantalla para mostrar texto e imágenes con nuestra API y aplicación.

Expansión PWM

La expansión PWM agrega 16 canales de salida PWM al Omega2. Úselo para controlar sus servomotores o LED.

Expansión de Ethernet

La expansión Ethernet expone el puerto ethernet en el Omega2. Puede usarlo para flashear el firmware de Omega2 o para convertir el Omega2 en un enrutador.

Expansión Bluetooth

Expansión GPS

La Expansión GPS agrega capacidad de GPS al Omega2. ¡Usa tu Omega2 para rastrear tu actividad al aire libre con Power Dock!

Como conclusión final el omega 2 plus es impresionante para su valor desde los 7,5 dolares, provisto con wifi y una expansión  para placa ethernet lo hace perfecto para Internet de las cosas.

Tal vez pueda interesarte proyectos en arduino, pic, robótica, telecomunicaciones, suscribete en http://www.youtube.com/user/carlosvolt?sub_confirmation=1 muchos videos con código fuentes completos y diagramas

SUSCRIBETE A NUESTROS BOLETINES, RECIBE EN TU CORREO LAS NOTICIAS MÁS DESTACADAS, SÓLO INGRESANDO TU CORREO ELECTRÓNICO

Hola!!! En esta entrada vamos a revisar un módulo TTS(Text to Speech) o módulo sintetizador de voz, aportado por DFRobot puede conseguir este módulo en página en el siguiente link Módulo sintetizador de voz

Tal vez pueda interesarte proyectos en arduino, pic, robótica, telecomunicaciones, suscribete en http://www.youtube.com/user/carlosvolt?sub_confirmation=1 muchos videos con código fuentes completos y diagramas

Introducción

¿Quieres que tu robot hable? ¿O alguna vez tus plantas dicen que tienen sed? El Módulo sintetizador de voz para Arduino hace que sea fácil hacerse realidad. Es hora de dar voz a tus robots y proyectos. El Módulo sintetizador de voz está diseñado para colocarse fácilmente en cualquier Arduino estándar. Utiliza un chip de síntesis de voz XFS5051CE de IFLYTEK que combina tecnología líder mundial y alto grado de integración. Se admiten idiomas como el chino y el inglés, dialectos como el cantonés y el habla mixta también son funcionales con este módulo. Es muy divertido hacer un pronóstico del tiempo con la voz de transmisión. Está utilizando la comunicación UART para que sea ampliamente compatible con la mayoría de las placas controladoras.

Especificación

• Velocidad de transmisión: 4800,9600,57600,115200
• Un LED indicador de ocupado
• Un indicador de encendido LED
• Voltaje: + 5V
• Tamaño: 56 * 53 mm
• Peso: 26 gramos
• 11 niveles de velocidad de habla
• Soporta el ideoma chino
• Soporta el ideoma inglés
• Tanto la voz masculina como femenina son compatibles
• Utilice los puertos serie de su Arduinos solamente

Comenzando

Presione el botón RST en la placa del controlador después de cargar el sketch, o afectará el uso normal.
Recuerde que el botón “RST” en el escudo del habla es solo el chip de síntesis del habla.
El led ocupado estará iluminado una vez, cuando presione “RST”.

#include <SpeechSynthesis.h>
void setup()
{
  Serial.begin(9600);
}
 byte ssr[500];//define a character string
void loop()
{ 
SpeechSynthesis.buf_init(ssr);//Clear the buffer
SpeechSynthesis.English(ssr,4,"5");//volume in grade 5
SpeechSynthesis.English(ssr,6,"cooki");//"6" means synthesis in English; "cooki"is the content
SpeechSynthesis.English(ssr,4,"5");
SpeechSynthesis.English(ssr,6,"cooki Clock, reset and supply management");
SpeechSynthesis.English(ssr,2,"10");
SpeechSynthesis.English(ssr,6,"cooki Clock, reset and supply management");
SpeechSynthesis.English(ssr,2,"5");//speed of speaking: grade 5
SpeechSynthesis.English(ssr,5," ");//speed,volume,intomation are all set into default
SpeechSynthesis.English(ssr,6,"cooki Clock, reset and supply management");
SpeechSynthesis.Espeaking(0,19,4,ssr);//Executive commands above, "0" is synthesis command; "19" select speaker; "4" speech function  

 while(Serial.read()!=0x41)//waiting synthesis complete
  {}
 while(Serial.read()!=0x4F)//waiting play complete
  {}   
SpeechSynthesis.buf_init(ssr);
SpeechSynthesis.English(ssr,6,"hello cooki 123");
SpeechSynthesis.Espeaking(0,19,4,ssr);
  
   while(Serial.read()!=0x41)
  {}
 while(Serial.read()!=0x4F)
  {}   
SpeechSynthesis.buf_init(ssr);
SpeechSynthesis.English(ssr,6,"hello cooki 123");
SpeechSynthesis.Espeaking(0,19,7,ssr);
  
while(1);
  
}

En el siguiente código vamos a hacer un contador descendente, y a medida que cambia cada número, una voz irá indicando cual es el número hasta llegar a cero, y en ese momento se encenderá un led y un buzzer sonará.

#include <SpeechSynthesis.h>
#include "U8glib.h"//libreriapara el control del display
U8GLIB_SH1106_128X64 u8g(U8G_I2C_OPT_NONE);  // I2C / TWI // Se habilita esta linea según el display a a usar en este caso el driver SH1106
int contador =0;
int led8=8;
void setup()
{
  Serial.begin(9600);
  pinMode(led8, OUTPUT);  
}
 byte ssr[500];//define a character string
void loop()
{ 

nueve();//Llama a la funciona llamada nueve
delay(1000);
ocho();
delay(1000);
siete();
delay(1000);
seis();
delay(1000);
cinco();
delay(1000);
cuatro();
delay(1000);
tres();
delay(1000);
dos();
delay(1000);
uno();
delay(1000);
cero();
delay(1000);
while(1);
  
}

int uno(void){
SpeechSynthesis.buf_init(ssr);//Inicializa el buffer
SpeechSynthesis.English(ssr,2,"5");//Velocidad de la voz
SpeechSynthesis.English(ssr,4,"5");//volumen de la voz 5
SpeechSynthesis.English(ssr,6,"one");//si es 6 el Idioma es inglés
//0->comando para inicializar la sintesis de voz
//17->voz masculina
//4->si es 4 dirá la frade corrido
//ssr es el buffer hasta 500 caracteres
SpeechSynthesis.Espeaking(0,17,4,ssr);
  contador=1;
display();
  }

int dos(void){
SpeechSynthesis.buf_init(ssr);//Inicializa el buffer
SpeechSynthesis.English(ssr,2,"5");//Velocidad de la voz
SpeechSynthesis.English(ssr,4,"5");//volumen de la voz 5
SpeechSynthesis.English(ssr,6,"two");//si es 6 el Idioma es inglés
//0->comando para inicializar la sintesis de voz
//17->voz masculina
//4->si es 4 dirá la frade corrido
//ssr es el buffer hasta 500 caracteres
SpeechSynthesis.Espeaking(0,17,4,ssr);
  contador=2;
display();
  }

int tres(void){
SpeechSynthesis.buf_init(ssr);//Inicializa el buffer
SpeechSynthesis.English(ssr,2,"5");//Velocidad de la voz
SpeechSynthesis.English(ssr,4,"5");//volumen de la voz 5
SpeechSynthesis.English(ssr,6,"three");//si es 6 el Idioma es inglés
//0->comando para inicializar la sintesis de voz
//17->voz masculina
//4->si es 4 dirá la frade corrido
//ssr es el buffer hasta 500 caracteres
SpeechSynthesis.Espeaking(0,17,4,ssr);
  contador=3;
display();
  }

int cuatro(void){
SpeechSynthesis.buf_init(ssr);//Inicializa el buffer
SpeechSynthesis.English(ssr,2,"5");//Velocidad de la voz
SpeechSynthesis.English(ssr,4,"5");//volumen de la voz 5
SpeechSynthesis.English(ssr,6,"four");//si es 6 el Idioma es inglés
//0->comando para inicializar la sintesis de voz
//17->voz masculina
//4->si es 4 dirá la frade corrido
//ssr es el buffer hasta 500 caracteres
SpeechSynthesis.Espeaking(0,17,4,ssr);
  contador=4;
display();
  }

int cinco(void){
SpeechSynthesis.buf_init(ssr);//Inicializa el buffer
SpeechSynthesis.English(ssr,2,"5");//Velocidad de la voz
SpeechSynthesis.English(ssr,4,"5");//volumen de la voz 5
SpeechSynthesis.English(ssr,6,"five");//si es 6 el Idioma es inglés
//0->comando para inicializar la sintesis de voz
//17->voz masculina
//4->si es 4 dirá la frade corrido
//ssr es el buffer hasta 500 caracteres
SpeechSynthesis.Espeaking(0,17,4,ssr);
  contador=5;
display();
  }

int seis(void){
SpeechSynthesis.buf_init(ssr);//Inicializa el buffer
SpeechSynthesis.English(ssr,2,"5");//Velocidad de la voz
SpeechSynthesis.English(ssr,4,"5");//volumen de la voz 5
SpeechSynthesis.English(ssr,6,"six");//si es 6 el Idioma es inglés
//0->comando para inicializar la sintesis de voz
//17->voz masculina
//4->si es 4 dirá la frade corrido
//ssr es el buffer hasta 500 caracteres
SpeechSynthesis.Espeaking(0,17,4,ssr);
contador=6;
display();
  }

int siete(void){
SpeechSynthesis.buf_init(ssr);//Inicializa el buffer
SpeechSynthesis.English(ssr,2,"5");//Velocidad de la voz
SpeechSynthesis.English(ssr,4,"5");//volumen de la voz 5
SpeechSynthesis.English(ssr,6,"seven");//si es 6 el Idioma es inglés
//0->comando para inicializar la sintesis de voz
//17->voz masculina
//4->si es 4 dirá la frade corrido
//ssr es el buffer hasta 500 caracteres
SpeechSynthesis.Espeaking(0,17,4,ssr);
contador=7;
display();
  }

int ocho(void){
SpeechSynthesis.buf_init(ssr);//Inicializa el buffer
SpeechSynthesis.English(ssr,2,"5");//Velocidad de la voz
SpeechSynthesis.English(ssr,4,"5");//volumen de la voz 5
SpeechSynthesis.English(ssr,6,"eight");//si es 6 el Idioma es inglés
//0->comando para inicializar la sintesis de voz
//17->voz masculina
//4->si es 4 dirá la frade corrido
//ssr es el buffer hasta 500 caracteres
SpeechSynthesis.Espeaking(0,17,4,ssr);
contador=8;
display();
  }

int nueve(void){
SpeechSynthesis.buf_init(ssr);//Inicializa el buffer
SpeechSynthesis.English(ssr,2,"5");//Velocidad de la voz
SpeechSynthesis.English(ssr,4,"5");//volumen de la voz 5
SpeechSynthesis.English(ssr,6,"nine");//si es 6 el Idioma es inglés
//0->comando para inicializar la sintesis de voz
//17->voz masculina
//4->si es 4 dirá la frade corrido
//ssr es el buffer hasta 500 caracteres
SpeechSynthesis.Espeaking(0,17,4,ssr);
contador=9;
display();
}

int cero(void){
SpeechSynthesis.buf_init(ssr);//Inicializa el buffer
SpeechSynthesis.English(ssr,2,"5");//Velocidad de la voz
SpeechSynthesis.English(ssr,4,"5");//volumen de la voz 5
SpeechSynthesis.English(ssr,6,"zero");//si es 6 el Idioma es inglés
//0->comando para inicializar la sintesis de voz
//17->voz masculina
//4->si es 4 dirá la frade corrido
//ssr es el buffer hasta 500 caracteres
SpeechSynthesis.Espeaking(0,17,4,ssr);
contador=0;
display();
digitalWrite(led8, HIGH);   // turn the LED on (HIGH is the voltage level)
delay(3000);                       // wait for a second
digitalWrite(led8, LOW);    // turn the LED off by making the voltage LOW
  }
int display(void){
  //--------Muestra nuestra el numero en pantalla-----------------
    u8g.firstPage();  
  do {
    draw();//Llama a la función draw
  } while( u8g.nextPage() );
  // Reconstruir la imagen después de un tiempo
  delay(50);
  }
void draw(void) {
 
  //Los comandos gráficos para volver a dibujar la pantalla completa deben colocarse aquí 
  
  u8g.setFont(u8g_font_unifont);
  u8g.setPrintPos(0, 20); 
  u8g.print("Conteo:");
  u8g.print(contador);
}

Circuito

Recuerden que Speech Synthesis Shield for Arduino lo pueden adquirir en la paginade DFRobot en:

Tal vez pueda interesarte proyectos en arduino, pic, robótica, telecomunicaciones, suscribete en http://www.youtube.com/user/carlosvolt?sub_confirmation=1 muchos videos con código fuentes completos y diagramas

SUSCRIBETE A NUESTROS BOLETINES, RECIBE EN TU CORREO LAS NOTICIAS MÁS DESTACADAS, SÓLO INGRESANDO TU CORREO ELECTRÓNICO

Antes que nada quería desearles una feliz navidad y un prospero año nuevo ;-).

Construcción de la estrella

Con motivo de estas fechas especiales he fabricado una estrella luminosa con led noepixel, que geenera un efecto muy bonitopara adornos nuestro árbol de navidad, pesebre, etc.

Su fabricación es muy sencilla y los materiales en su mayoría son económicos y de fácil adquisición.

Lo primero que debemos hacer imprimir en una hoja de papel una estrella y el objeto que más te agrade recortarlo y pegarlo en un papel, a continuación lo pegas en un cartón y lo dejar secar durante algún tiempo.

Una vez seco, con un cutter cortar las orillas de la estrella y la separas del cartón.

Deberás cortan una tira de cartón de aproximadamente unos 10 x 2 centímetros, y unirás sus puntas con pegamento termo-fusible (barras de silicona, comúnmente conocida) tratando de formar una figura circular. Esta figura la pegaras en la parte trasera de la estrella en el centro y la pegaras con el mismo pegamento.

En cada punta de la estrella vamos a pegar las luces led neopixel, tratando de ser lo más prolijo posible, para que no se noten en la parte delantera de la estrella el cableado.

Armado del circuito

Como he utilizado led neopixel de montaje superficial, ha sido necesario armar en un plaqueta experimental toda la circuitería necesaria, para su correcto funcionamiento.

Este circuito se limita a pocos componentes como son el propio led noepixel y un capacitor de montaje superficial de 0.1 uF, un pequeño troso de plaqueta estaño y 3 cables de distintos colores.

Pin out del led noepixel WS2812B

Observesé que en el pin número 3 hay una pequeña muesca, tenerla en cuenta para determinar fácilmente el pinout del del led.

Imagen real del led neopixel

Diagrama eléctrico de conexión

Conexión en cascada entre led noepixel

Capacitor SMD de 0.1 uF

Circuito con arduino uno

Código Fuente

Para poder utilizar este código fuente debemos instalar la librería  Adafruit Neopixel y en este momento estoy usando la versión 1.1.3, si nunca has instalado una librería en el ide de Arduino por favor mira el video, ahí están los pasos para poder hacerlo fácilmente.

Este ejemplo viene acompañado junto con la librería llamado RGBWstrandtest, sólo he hecho una pequeña modificación en la linea #define BRIGHTNESS 50, el valor de 50 lo he cambiado por 255 para una mayor iluminación de los led. Esta modificación queda a gusto de cada persona.

En #define PIN 6, con esto indicamos que pin del arduino vamos a usar en este caso el pin número 6.

#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
  #include <avr/power.h>
#endif

#define PIN 6

#define NUM_LEDS 60

#define BRIGHTNESS 255

Adafruit_NeoPixel strip = Adafruit_NeoPixel(NUM_LEDS, PIN, NEO_GRBW + NEO_KHZ800);

byte neopix_gamma[] = {
    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  1,  1,  1,
    1,  1,  1,  1,  1,  1,  1,  1,  1,  2,  2,  2,  2,  2,  2,  2,
    2,  3,  3,  3,  3,  3,  3,  3,  4,  4,  4,  4,  4,  5,  5,  5,
    5,  6,  6,  6,  6,  7,  7,  7,  7,  8,  8,  8,  9,  9,  9, 10,
   10, 10, 11, 11, 11, 12, 12, 13, 13, 13, 14, 14, 15, 15, 16, 16,
   17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, 23, 24, 24, 25,
   25, 26, 27, 27, 28, 29, 29, 30, 31, 32, 32, 33, 34, 35, 35, 36,
   37, 38, 39, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 50,
   51, 52, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 66, 67, 68,
   69, 70, 72, 73, 74, 75, 77, 78, 79, 81, 82, 83, 85, 86, 87, 89,
   90, 92, 93, 95, 96, 98, 99,101,102,104,105,107,109,110,112,114,
  115,117,119,120,122,124,126,127,129,131,133,135,137,138,140,142,
  144,146,148,150,152,154,156,158,160,162,164,167,169,171,173,175,
  177,180,182,184,186,189,191,193,196,198,200,203,205,208,210,213,
  215,218,220,223,225,228,231,233,236,239,241,244,247,249,252,255 };


void setup() {
  // This is for Trinket 5V 16MHz, you can remove these three lines if you are not using a Trinket
  #if defined (__AVR_ATtiny85__)
    if (F_CPU == 16000000) clock_prescale_set(clock_div_1);
  #endif
  // End of trinket special code
  strip.setBrightness(BRIGHTNESS);
  strip.begin();
  strip.show(); // Initialize all pixels to 'off'
}

void loop() {
  // Some example procedures showing how to display to the pixels:
  colorWipe(strip.Color(255, 0, 0), 50); // Red
  colorWipe(strip.Color(0, 255, 0), 50); // Green
  colorWipe(strip.Color(0, 0, 255), 50); // Blue
  colorWipe(strip.Color(0, 0, 0, 255), 50); // White

  whiteOverRainbow(20,75,5);  

  pulseWhite(5); 

  // fullWhite();
  // delay(2000);

  rainbowFade2White(3,3,1);


}

// Fill the dots one after the other with a color
void colorWipe(uint32_t c, uint8_t wait) {
  for(uint16_t i=0; i<strip.numPixels(); i++) {
    strip.setPixelColor(i, c);
    strip.show();
    delay(wait);
  }
}

void pulseWhite(uint8_t wait) {
  for(int j = 0; j < 256 ; j++){
      for(uint16_t i=0; i<strip.numPixels(); i++) {
          strip.setPixelColor(i, strip.Color(0,0,0, neopix_gamma[j] ) );
        }
        delay(wait);
        strip.show();
      }

  for(int j = 255; j >= 0 ; j--){
      for(uint16_t i=0; i<strip.numPixels(); i++) {
          strip.setPixelColor(i, strip.Color(0,0,0, neopix_gamma[j] ) );
        }
        delay(wait);
        strip.show();
      }
}


void rainbowFade2White(uint8_t wait, int rainbowLoops, int whiteLoops) {
  float fadeMax = 100.0;
  int fadeVal = 0;
  uint32_t wheelVal;
  int redVal, greenVal, blueVal;

  for(int k = 0 ; k < rainbowLoops ; k ++){
    
    for(int j=0; j<256; j++) { // 5 cycles of all colors on wheel

      for(int i=0; i< strip.numPixels(); i++) {

        wheelVal = Wheel(((i * 256 / strip.numPixels()) + j) & 255);

        redVal = red(wheelVal) * float(fadeVal/fadeMax);
        greenVal = green(wheelVal) * float(fadeVal/fadeMax);
        blueVal = blue(wheelVal) * float(fadeVal/fadeMax);

        strip.setPixelColor( i, strip.Color( redVal, greenVal, blueVal ) );

      }

      //First loop, fade in!
      if(k == 0 && fadeVal < fadeMax-1) {
          fadeVal++;
      }

      //Last loop, fade out!
      else if(k == rainbowLoops - 1 && j > 255 - fadeMax ){
          fadeVal--;
      }

        strip.show();
        delay(wait);
    }
  
  }



  delay(500);


  for(int k = 0 ; k < whiteLoops ; k ++){

    for(int j = 0; j < 256 ; j++){

        for(uint16_t i=0; i < strip.numPixels(); i++) {
            strip.setPixelColor(i, strip.Color(0,0,0, neopix_gamma[j] ) );
          }
          strip.show();
        }

        delay(2000);
    for(int j = 255; j >= 0 ; j--){

        for(uint16_t i=0; i < strip.numPixels(); i++) {
            strip.setPixelColor(i, strip.Color(0,0,0, neopix_gamma[j] ) );
          }
          strip.show();
        }
  }

  delay(500);


}

void whiteOverRainbow(uint8_t wait, uint8_t whiteSpeed, uint8_t whiteLength ) {
  
  if(whiteLength >= strip.numPixels()) whiteLength = strip.numPixels() - 1;

  int head = whiteLength - 1;
  int tail = 0;

  int loops = 3;
  int loopNum = 0;

  static unsigned long lastTime = 0;


  while(true){
    for(int j=0; j<256; j++) {
      for(uint16_t i=0; i<strip.numPixels(); i++) {
        if((i >= tail && i <= head) || (tail > head && i >= tail) || (tail > head && i <= head) ){
          strip.setPixelColor(i, strip.Color(0,0,0, 255 ) );
        }
        else{
          strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) & 255));
        }
        
      }

      if(millis() - lastTime > whiteSpeed) {
        head++;
        tail++;
        if(head == strip.numPixels()){
          loopNum++;
        }
        lastTime = millis();
      }

      if(loopNum == loops) return;
    
      head%=strip.numPixels();
      tail%=strip.numPixels();
        strip.show();
        delay(wait);
    }
  }
  
}
void fullWhite() {
  
    for(uint16_t i=0; i<strip.numPixels(); i++) {
        strip.setPixelColor(i, strip.Color(0,0,0, 255 ) );
    }
      strip.show();
}


// Slightly different, this makes the rainbow equally distributed throughout
void rainbowCycle(uint8_t wait) {
  uint16_t i, j;

  for(j=0; j<256 * 5; j++) { // 5 cycles of all colors on wheel
    for(i=0; i< strip.numPixels(); i++) {
      strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) & 255));
    }
    strip.show();
    delay(wait);
  }
}

void rainbow(uint8_t wait) {
  uint16_t i, j;

  for(j=0; j<256; j++) {
    for(i=0; i<strip.numPixels(); i++) {
      strip.setPixelColor(i, Wheel((i+j) & 255));
    }
    strip.show();
    delay(wait);
  }
}

// Input a value 0 to 255 to get a color value.
// The colours are a transition r - g - b - back to r.
uint32_t Wheel(byte WheelPos) {
  WheelPos = 255 - WheelPos;
  if(WheelPos < 85) {
    return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3,0);
  }
  if(WheelPos < 170) {
    WheelPos -= 85;
    return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3,0);
  }
  WheelPos -= 170;
  return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0,0);
}

uint8_t red(uint32_t c) {
  return (c >> 16);
}
uint8_t green(uint32_t c) {
  return (c >> 8);
}
uint8_t blue(uint32_t c) {
  return (c);
}

Hoja de datos del led WS2812B

WS2812B

Quería desear a todos feliz navidad y un mejor año nuevo.

VIDEOS DE NAVIDAD DE AÑOS ANTERIORES

Tal vez pueda interesarte proyectos en arduino, pic, robótica, telecomunicaciones, suscribete en http://www.youtube.com/user/carlosvolt?sub_confirmation=1 muchos videos con código fuentes completos y diagramas

SUSCRIBETE A NUESTROS BOLETINES, RECIBE EN TU CORREO LAS NOTICIAS MÁS DESTACADAS, SÓLO INGRESANDO TU CORREO ELECTRÓNICO

En este proyecto vamos a crear un detector de llama o fuego con arduino y el sensor ky-26, este sensor de llama óptico, permite detectar la existencia de combustión por la luz emitida por fuego.

Se llama fuego al conjunto de partículas o moléculas incandescentes de materia combustible, capaces de emitir luz visible, producto de una reacción química de oxidación violenta. Las llamas son las partes del fuego que emiten luz visible.

Peligros

El fuego conlleva un conjunto de peligros, el primero y más evidente son las quemaduras. También otros como la intoxicación por inhalación de humo.

Con este proyecto se intenta crear un dispositivo económico que ayude a prevenir incendios o su detección temprana para intentar salvar vidas y bienes económicos, como estructuras edilicias, mercadería, documentos, etc.

Sobre el módulo detector de llama

• Este módulo es sensible a una llama y su radiación. También puede detectar fuente de luz ordinaria en el rango de una longitud de onda de 760 nm a 1100 nm.
• El sensor de Llama puede emitir señal digital o analógica.
• Se puede usar como una alarma de incendios.
• Detección de ángulo de unos 60 grados, particularmente sensible al espectro de la llama.
• Sensibilidad ajustable (en azul ajuste del potenciómetro digital).
• La salida del comparador, señal limpia, buena onda, la capacidad de conducción, más que 15mA.
• Voltaje de funcionamiento de 3.3 V-5 V.
• La forma de salida: salidas de conmutación digital (0 y 1) y salida de tensión analógica AO.
• Agujeros de perno fijo para una fácil instalación.
• Pequeñas placas PCB Tamaño: 3.2 cm x 1.4 cm.
• Usa un amplificador LM393 como comparador de voltaje

Uso del módulo

• Una pequeña placa de interfaz de salida puede ser conectado directamente al microcontrolador
• El sensor y la llama tiene que mantener una cierta distancia, a fin de no dañar por temperatura al sensor
• La llama de un encendedor se ha probada a una distancia de 80 cm.
• Pequeñas placas de salida analógica y con un procesador de conversión AD, se puede obtener una mayor precisión.

Espectro de una llama

El espectro de emisión de una llama depende de los elementos que intervienen en la reacción. En el caso de combustión de productos con carbón en presencia del oxígeno tenemos dos picos característicos en ultravioleta en longitudes de onda de 185nm-260nm y en infrarrojo en longitudes de onda 4400-4600nm.

Los sensores de llama son ampliamente utilizados en la industria. Muchas máquinas ejecutan procesos susceptibles de generar llamas, como por ejemplo procesos de mecanizado o de electroerosión. Frecuentemente se realizan en presencia de elementos combustibles como aceite o viruta.

Por este motivo se incorporan sensores de llaman como dispositivo de seguridad, permitiendo detener el proceso en caso de detectar cualquier indicio de combustión. Estos dispositivos se ajustan a las longitudes de onda características de la aparición de la llama y normalmente combinan las señales ultravioleta y de infrarrojo.

MATERIALES

Detector de llama

Arduino uno

Buzzer

Cables Dupont

CIRCUITO

CÓDIGO FUENTE

int buzzer = 11;      // selecciona el pin para el zumbador
int valorSensor = 0;  // variable para almacenar el valor proveniente del sensor
void setup() {
 //Seteo de la velocidad del puerto serial
 Serial.begin(9600);
 // declarar buzzer como una SALIDA:
  pinMode(buzzer, OUTPUT);
}
void loop() {
  // leer el valor del sensor:
  valorSensor = analogRead(A0);
   Serial.println(valorSensor);
  // activa el buzzer
  if (valorSensor < 500){
   digitalWrite(buzzer, HIGH);
   delay(100);
  // Desactiva el buzzer
  digitalWrite(buzzer, LOW);
  delay(50);  
    }
 }

HOJA DE DATOS DEL SENSOR DE FLAMA

Flame-sensor-arduino

Tal vez pueda interesarte proyectos en arduino, pic, robótica, telecomunicaciones, suscribete en http://www.youtube.com/user/carlosvolt?sub_confirmation=1 muchos videos con código fuentes completos y diagramas

SUSCRIBETE A NUESTROS BOLETINES, RECIBE EN TU CORREO LAS NOTICIAS MÁS DESTACADAS, SÓLO INGRESANDO TU CORREO ELECTRÓNICO

VIDEO RECOMENDADO

Hola que tal, en esta entrada veremos como hacer un sistema detector de incendios forestales, con aviso por mensaje de texto, de la ubicación del siniestro, gracias al gps integrado del módulo sim808, otorgado por la gente de DFRobot, veremos el código fuente, algunas características y funcionamiento del módulo sim808, en un ambiente exterior, esta es la continuación del de un proyecto anterior , donde veíamos como hacer un sistema detector de llama muy simple para el hogar.

Introducción

Este sistema intenta prevenir incendios en bosques y campos, donde un siniestro de este tipo puede generar grandes perdidas económicas, daños materiales cuantiosos, destrucción de la flora y fauna del lugar causando un daño ecológico de grandes magnitudes, pero lo más importante es salvar vidas humanas.

El principio de funcionamiento es el siguiente, al detectar fuego por parte del sensor de llama, este enviará una señal analógica al arduino, que dependiendo de su valor, activará el envío de un mensaje de texto con las coordenadas gps donde se está produciendo el incendio.

Para este proyecto vamos a necesitar un sensor de llama, un arduino uno, un módulo sim808, una batería, cables, puede revisar la siguiente lista de materiales:

Arduino uno

Sim808

Sensor de llama

Sobre el módulo detector de llama

• Este módulo es sensible a una llama y su radiación. También puede detectar fuente de luz ordinaria en el rango de una longitud de onda de 760 nm a 1100 nm.
• El sensor de Llama puede emitir señal digital o analógica.
• Se puede usar como una alarma de incendios.
• Detección de ángulo de unos 60 grados, particularmente sensible al espectro de la llama.
• Sensibilidad ajustable (en azul ajuste del potenciómetro digital).
• La salida del comparador, señal limpia, buena onda, la capacidad de conducción, más que 15mA.
• Voltaje de funcionamiento de 3.3 V-5 V.
• La forma de salida: salidas de conmutación digital (0 y 1) y salida de tensión analógica AO.
• Agujeros de perno fijo para una fácil instalación.
• Pequeñas placas PCB Tamaño: 3.2 cm x 1.4 cm.
• Usa un amplificador LM393 como comparador de voltaje

Cables dupont

Batería 12 voltios (puede ser un fuente de 12 al menos para hacer las pruebas iniciales)

Una caja con filtro(opcional)

Circuito

Código fuente

#include <DFRobot_sim808.h>
  //Cambiar por tu número de telefono
  #define numero_telefono "1234567"  
  DFRobot_SIM808 sim808(&Serial);
int valorSensor = 0;
  void setup() {
    Serial.begin(9600);//Velocidad del puerto serial
    //******** Inicializa el módulo sim808 *************
    while(!sim808.init()) {
        delay(1000);
        Serial.print("Error al iniciar Sim808\r\n");
    }
    //************* Encienda la alimentación del GPS ************
    if( sim808.attachGPS())
        Serial.println("Exito al encender el GPS");
    else
        Serial.println("Falla al encender el GPS");
  }

  void loop() {
     //************** Obtener datos del GPS *******************
     // leer el valor del sensor:
  valorSensor = analogRead(A0);//Se imprime el valor obtenido del sensor
    if (valorSensor < 500){//Si es menor a 500
     if (sim808.getGPS()) {//Si hay datos disponibles del GPS
//Imprimimos la posición obtenida      
      Serial.print("latitude :");
      Serial.println(sim808.GPSdata.lat);
      Serial.print("longitude :");
      Serial.println(sim808.GPSdata.lon);
      String latitud =  String(sim808.GPSdata.lat, 6); //Obtenemos la latitud con una precisión de 6 dígitos 
      String longitud = String(sim808.GPSdata.lon, 6);//Obtenemos la longitud con una precisión de 6 dígitos 
      String maps ="https://maps.google.com/maps?q=";//Asignamos esta url a los datos obtenidos 
      String datos= maps + latitud + "+" + longitud;
//******** convierte los datos obtenidos de string a un arreglo de caracteres **********
String textoString = datos;
char textoCaracter[65];
textoString.toCharArray(textoCaracter, 65);
Serial.println(textoCaracter);
      //************* Enviamos el sms con la posicion del incencio ************
     Serial.println(valorSensor);
        sim808.detachGPS();//Apaga el gps
        sim808.sendSMS(numero_telefono,textoCaracter);
         }
    }
  }

Acerca del módulo sim808 de dfrobot

SIM808 GPS / GPRS / GSM arduino shield es una tecnología de navegación GSM / GPRS integrada cuatrbanda y tecnología de navegación GPS compatible con arduino. En un tamaño de tarjeta de crédito.

Comparado con SIM908 de la generación anterior, SIM808 mejoró el rendimiento y la estabilidad. Además de las funciones normales de SMS y teléfono, el escudo también es compatible con MMS, DTMF, FTP y otras funciones. Puede lograr la adquisición de datos, el transceptor de datos inalámbrico, la aplicación IoT y la orientación GPS. Integra micrófono interno y conector para auriculares, lo que le ahorrará costos y hará que su proyecto sea fácil. también se puede conectar directamente antenas GSM y GPS mediante un conector de antena externo.

SIM808 GPS / GPRS / GSM escudo Arduino V1.0 utiliza la última versión del módulo Simcom SIM808, en comparación con el módulo SIM808 anterior disponible en el mercado, el nuevo módulo tiene una mejor estabilidad.

Especificación

• Voltaje de funcionamiento: 5V
• Potencia de entrada: 7-23V
• Cuatribanda 850/900/1800 / 1900MHz
• GPRS multi-slot clase 12/10
• Estación móvil GPRS clase B
• Cumple con GSM fase 2/2 +
  • Clase 4 (2 W @ 850 / 900MHz)
  • Clase 1 (1 W @ 1800 / 1900MHz)
• Soporta el modo de bajo consumo de energía: modo 100mA @ 7V-GSM
• Soporte de control de comando AT (3GPP TS 27.007,27.005 y SIMCOM Enhanced AT Commands)
• Soporte de tecnología de navegación por satélite GPS
• Indicador LED de estado de soporte: estado de la fuente de alimentación, estado de la red y modos de funcionamiento
• Ambiente de trabajo: -40 ℃ ~ 85 ℃
• Tamaño: 69 * 54 mm / 2.71 * 2.12 pulgadas

Pinout del escudo

Interfaz y precauciones del módulo:

1. Pines ocupados: D0, D1, D12, el pin digital “D12” está conectado a la potencia del módulo SIM808 GPIO. Se puede usar como control de encendido / apagado del módulo SIM808.
2. SIM808 MIC incorpora un micrófono, el jack  3.5mm están usando el mismo canal MIC, cuando usted conecta su micrófono, el MIC interno se desconectará automáticamente.
3. Botón de encendido – pulsador del módulo SIM808, presione brevemente 1s para iniciar SIM808, mantenga presionado 3s para apagarlo.
4. LED “ENCENDIDO” – Indicador de encendido SIM808, solo cuando se conecta una fuente de alimentación externa, el módulo puede funcionar correctamente.
5. Net – Indicador de señal GSM
   1. Flash rápido: Búsqueda de red
   2. Flash lento (3s una vez): registro de red completo
6. Interruptor de función
   1. Ninguno– PIN de serie SIM808 vacante para descargar el boceto, marque aquí.
   2. USB_DBG– Cuando la tarjeta de expansión se conectó al Arduino, seleccione aquí, para hacer que el SIM808 se comunique con la PC para realizar una depuración (depuración de AT).
   3. Arduino– Cuando la tarjeta de expansión se conecta al Arduino, seleccione aquí para que SIM808 se comunique con el Arduino.

Depuración USB (comando AT)

En esta sección, enviaremos comandos AT a través del puerto serie para depurar el escudo de expansión SIM808. Consulte el conjunto de comandos SIM808 AT para obtener más funciones.

Preparación

• Hardware:
  • Arduino UNO x1
  • Tarjeta de expansión SIM808 x1
  • Fuente de alimentación externa x1

• Software :
  • Arduino IDE Haga clic para descargar Arduino IDE de Arduino®
  • Asistente de depuración en serie (En esta sección, usamos DF Serial Debugger by Lisper )

”’PASOS”’

1. Conecte su tarjeta SIM en el escudo de expansión SIM808 y tape el escudo de expansión en Arduino UNO, mientras tanto, no olvide conectar una fuente de alimentación externa.
2. Seleccione el interruptor de función a Ninguno , descarga un código de muestra “blink” para asegurarte de que el puerto serie no esté ocupado.
3. Presione el botón de encendido de Arranque y espere a que la tarjeta SIM registre una red correctamente, el LED indicador de red parpadea lentamente (cada 3s).
4. Deslice el interruptor de función a USB_DBG , luego podemos comunicarnos directamente con el chip SIM808 a través del asistente del puerto serie.

Hacer una llamada telefónica

Enviar AT en el asistente del puerto serie, si devuelve OK , significa que se ha establecido la comunicación serial. Sigue la figura, ingresa los comandos AT, deberías obtener el mismo contenido.

Contestar el teléfono y Culgar

Enviar un SMS

Lee un SMS

Comunicación TCP

Orientación GPS

Nota: La antena del GPS debe colocarse afuera antes de que pueda obtener una salida estable de datos de ubicación del GPS.

Enviar AT + CGSN PWR = 1 comando (Abrir la alimentación del GPS)
 Enviar AT + CGNSTST = 1 comando (Recibir datos de GPS del puerto serie)

Si la antena del GPS se colocó afuera, debería obtener los datos correctos pronto.
 Cuando desee pausar la salida de datos GPS, puede enviar el comando <b>AT + CGNSTST = 0</b> para pausar la salida de datos GPS.

Cuando desee desactivar la función de GPS, puede enviar un comando AT + CGNSPWR = 0 para desactivar la alimentación del GPS. Envíe AT + CPOWD = 1 para apagar el chip SIM808.

Instrucciones más emocionantes, consulte el comando AT en la página del final.

Estos dos códigos de prueba son muy simples y fáciles de entender. Solo necesita ingresar los comandos en serie de AT correspondientes, usted alcanzaría las funciones correspondientes.

SIM808 Modo de bajo consumo de energía

Modo de funcionalidad mínima

El sistema se reducirá a un modo más simple en el modo de funcionalidad mínima. Ahorrará más consumo de energía en este modo.

• AT + CFUN = <diversión> <diversión> = 0,1,4
  • AT + CFUN = 0 : modo de funcionalidad mínima. En este modo, aún puede seguir utilizando el puerto serie, pero se deshabilitará el comando AT con funciones de RF y tarjeta SIM.
  • AT + CFUN = 1 : modo de función completa (predeterminado).
  • AT + CFUN = 4 : modo avión. En este modo, aún puede seguir utilizando el puerto serie, pero se deshabilitará el comando AT con funciones de RF y tarjeta SIM.

Pueden comprar el módulo sim808 de dfrobot en el sigueinte link (clik en la imagen)

Video recomendado

Tal vez pueda interesarte proyectos en arduino, pic, robótica, telecomunicaciones, suscribete en http://www.youtube.com/user/carlosvolt?sub_confirmation=1 muchos videos con código fuentes completos y diagramas

SUSCRIBETE A NUESTROS BOLETINES, RECIBE EN TU CORREO LAS NOTICIAS MÁS DESTACADAS, SÓLO INGRESANDO TU CORREO ELECTRÓNICO

En esta entrada revisaremos una pantalla de tinta electrónica de 4.3 pulgadas provista por DFRobot, pueden adquirirla en https://www.dfrobot.com/product-1312.html

Visión general

Este es un módulo de pantalla E-Ink de interfaz serial, 4.3 pulgadas, resolución 800 × 600, con bibliotecas de fuentes integradas, consumo de energía ultra bajo.

No tiene que saber nada sobre los complejos detalles subyacentes de e-Paper, ni los algoritmos específicos de visualización de gráficos, textos e imágenes. Todo lo que necesita es la interfaz serial, y todo lo que importa es su creatividad.

Caracteristicas

• Fácil de usar, muestra cualquier contenido a través de una interfaz serial, incluyendo gráficos geométricos, textos e imágenes
• Bibliotecas de fuentes incrustadas, admite fuentes chinas GBK de 32, 48 y 64 puntos y fuentes en inglés
• El NandFlash incorporado de 128MB, permite que los datos de fuente / imagen se almacenen en una tarjeta TF externa o en el NandFlash interno
• Visualización de 4 niveles de grises, resolución 800 × 600
• Velocidad en baudios de la interfaz serie ajustable, 115200 por defecto cuando se enciende
• Alimentado desde 3.3V a 5V, compatible con nivel lógico.
• Consumo de energía ultra bajo, corriente de reposo inferior a 5 mA
• Viene con software de computadora host, controlelo directamente en su computadora

Aplicaciones

• libro electrónico
• Centro comercial POS
• Etiqueta de precio
• Instrumento de la industria

Definiciones de Pin

• VCC: 3.3V ~ 5.5V
• GND: GND
• DOUT: salida de datos en serie
• DIN: datos serie en
• WAKE_UP: despertador externo
• RST: reset externo

• Encendido del sistema

Después de encendido, la pantalla se actualiza a blanco. En este momento, si no se utiliza una tarjeta TF externa, el indicador de estado parpadeará 3 veces y luego continuará. Cuando se utiliza una tarjeta TF externa, el indicador de estado se iluminará y continuará sin parpadear.

• Almacenamiento

Una vez encendido, el sistema lee la fuente y los datos de imagen del NandFlash interno de forma predeterminada.

Cuando utilice una tarjeta TF externa, debe formatear la tarjeta TF en un sistema FAT32 y colocar las bibliotecas de fuentes proporcionadas por Waveshare y las imágenes que desea mostrar en la tarjeta TF externa antes de usarla.

Cuando utilice el NandFlash interno, debe importar las bibliotecas de fuentes y los archivos de imagen que desea mostrar al NandFlash interno de antemano. Para obtener información más detallada, consulte la Sección 2.2.

• Indicador de estado

El indicador de estado se enciende cuando el sistema funciona correctamente y se apaga cuando el sistema entra en modo de suspensión. Un flanco ascendente en el pin WAKE_UP de la MCU externa puede activar el sistema. Y el indicador de estado se iluminará y permanecerá encendido después de salir del modo de suspensión.

• Bibliotecas de fuentes

La fuente en inglés de 32, 48 y 64 puntos incorporada en el sistema siempre está disponible sin usar la tarjeta TF o NandFlash; sin embargo, para la fuente china de 32, 48 y 64 puntos, debe almacenar el archivo de biblioteca relativa en la tarjeta TF o en la NandFlash antes de usarla.

• Visualización de la imagen

El sistema admite la visualización de imágenes de mapa de bits de 1 y 2 bits. Para otros formatos de imagen, debe convertir estas imágenes al formato especificado con la herramienta en las Demos para mostrarlas.

El nombre de la imagen debe estar en caracteres en mayúsculas en inglés con una longitud inferior a 10 caracteres, en los que aparece el símbolo «.» está incluido.

Por ejemplo:

PIC7.BMP y PIC789.BMP son nombres de imagen correctos;

PIC7890.BMP es un nombre de imagen incorrecto.

Cómo utilizar

Fuente de alimentación

Si el módulo de papel electrónico se alimenta con 3.3 V desde un determinado módulo serie, la actualización del papel electrónico puede causar inestabilidad del módulo serie debido a la alta corriente. En este caso, intente con una fuente de alimentación de 5 V del módulo en serie, o pruebe con otro módulo en serie.

Cómo generar imágenes de mapa de bits.

• Asegúrese de que la resolución de la imagen sea inferior a 800×600 píxeles. Inicie la herramienta mspaint.exe en Windows para abrir la imagen que desea convertir;
• Seleccione la opción de mapa de bits de 24 bits en la lista Guardar como tipo , para guardar la imagen como un archivo de formato bmp;
• Inicie la herramienta de software proporcionada por Waveshare: uC-GUI-BitmapConvert.exe ;
• Haga clic en Archivo -> Abrir, y seleccione la imagen de mapa de bits que desea convertir;
• Haga clic en Imagen -> Convertir en -> Gray4 (2 BPP);
• Haga clic en Archivo -> Guardar como, y seleccione la opción Archivo de mapa de bits de Windows (* .bmp) en la lista Guardar como tipo , y luego ingrese el nombre de archivo correcto y guarde la imagen. Por favor, tome nota del formato del nombre del archivo.

Cómo trabajar con PC

Hemos diseñado el software para que E-Paper funcione con PC. Con este software, los usuarios pueden operar fácilmente diferentes pantallas básicas en el E-Paper a través de una PC. Además, debe aplicarse un módulo USB a serie para establecer la comunicación entre el e-Paper y la PC. Aquí, tomaremos el módulo serial CP2102 USB UART Board (mini) como ejemplo para ilustrar la aplicación. Para obtener información más detallada sobre este módulo en serie, consulte el Apéndice.

• Conexión de hardware
• Ajuste el pin VCCIO en el CP2102 a 5V;
• Conecte el CP2102 al E-Paper con el cable de salto, en el cual el cable rojo del cable se conecta al pin VCCIO en el CP2102, y el cable negro al pin GND, el cable blanco al pin RXD y el verde Cable al pin TXD.

Tarjeta UART USB CP2102	E-papel de 4.3 pulgadas
VCCIO	rojo
GND	Negro
RXD	Blanco
TXD	Verde

• Conecte el CP2102 a la PC mediante un cable USB. Ahora, el E-Paper está encendido y su indicador de estado se ilumina.

• Instalación de software

Descomprima el software en el directorio de instalación y luego haga doble clic en el archivo «install.bat». Luego, verá que aparecerá un cuadro de diálogo como se muestra a continuación, si el software se instaló correctamente.

Haga doble clic en EPSCOMM.exe para iniciar el software:

Compruebe el Administrador de dispositivos y configure el puerto serie correspondiente. Haga clic en el botón Abrir, y luego en el botón Agitar las manos. El módulo de papel electrónico devolverá el mensaje «OK», si la comunicación está establecida.

• Bibliotecas de fuentes e importación de imágenes.
• Prepare una tarjeta micro SD (aquí tomamos una tarjeta micro SD 8G como ejemplo) y formatee la tarjeta micro SD en un sistema FAT32 con un tamaño de unidad de asignación de 4096 bytes. Copie las bibliotecas de fuentes y los archivos de imagen proporcionados por Waveshare en la tarjeta micro SD. Cuando haya terminado, inserte la tarjeta micro SD en el E-Paper.
• Haga clic en el botón Cargar fuente. Luego, el indicador de estado en el papel electrónico parpadeará 3 veces, lo que indica que la importación comienza. Cuando termine, el indicador de estado parpadeará 3 veces nuevamente y el módulo de papel electrónico devolverá el mensaje «OK», lo que indica que la importación de la biblioteca de fuentes se completó correctamente.

• Haga clic en el botón Cargar imagen. Luego, el indicador de estado en el papel electrónico parpadeará 3 veces, lo que indica que la importación comienza. Cuando termine, el indicador de estado volverá a parpadear 3 veces y el módulo de papel electrónico devolverá el mensaje «OK», lo que indica que la importación de imágenes se completó correctamente.

Observaciones:

[1] Una vez que realice la operación, verifique el indicador de estado. Parpadea cuando comienza la importación. Ahora, espera el final de la importación.

[2] Normalmente, solo necesita importar las imágenes que desea, pero no necesita importar la biblioteca de fuentes, ya que se ha importado de forma predeterminada.

• Prueba de pantalla

• Mostrar texto

Introduzca el texto «¡Hola mundo!» en el cuadro de entrada, y configure las opciones de coordenadas X1 e Y1 en 100. Luego, haga clic en el botón Carácter y luego en el botón Actualizar. Ahora, puedes ver el texto ingresado en la pantalla.

• Mostrar imagen

Ingrese el nombre de la imagen que desea mostrar en el cuadro de Entrada y configure las opciones de coordenadas X1 e Y1 en 0. Luego, haga clic en el botón Imagen y luego en el botón Actualizar. Ahora, puedes ver la imagen correspondiente se muestra en la pantalla.

• Forma de pantalla

Para dibujar formas, es posible que deba ingresar los parámetros enumerados en la siguiente tabla:

	Coordinar (X1, Y1)	Coordinar (X2, Y2)	Coordinar (X3, Y3)	Radio (R)
Punto	●
Línea	●	●
Rectángulo	●	●
Rectángulo relleno	●	●
Circulo	●			●
Círculo lleno	●			●
Triángulo	●	●	●
Triángulo lleno	●	●	●

• Otros ajustes

• Establezca el área de almacenamiento, seleccione las ubicaciones de almacenamiento de la biblioteca de fuentes y las imágenes, ubicación predeterminada: NandFlash;
• Establecer la dirección de visualización;
• Establezca el color de dibujo, la opción Color de primer plano para el texto se establece en Negro y la opción Color de fondo para el fondo se establece en Blanco de forma predeterminada;
• Establecer velocidad de transmisión, por defecto: 115200; no se recomienda modificar esta opción con frecuencia;
• Establecer el tamaño de fuente del carácter Inglés;
• Establecer el tamaño de fuente del carácter chino.

Observaciones:

[1] Cuando termine cada comando, habrá una respuesta correspondiente. Normalmente, devolverá «OK»;

[2] Para dibujar punto (s) o línea (s), o mostrar texto (s) o imagen (es), debe hacer clic en el botón Actualizar para actualizar la pantalla en la pantalla de E-Paper cada vez que finalice cada dibujo.

[3] Es posible que deba esperar la respuesta un momento después de hacer clic en el botón Mostrar imagen, ya que los datos de la imagen son grandes.

Para arduino

• Conexión de hardware

Aquí, tomamos la placa de desarrollo Arduino UNO como ejemplo para ilustrar la aplicación. Conecte la placa de desarrollo al papel electrónico con un cable serie como se muestra en la siguiente tabla. Para obtener más información sobre esta placa de desarrollo, consulte el Apéndice.

Conexión entre Arduino UNO y 4.3inch e-Paper:

Arduino UNO	E-papel de 4.3 pulgadas
5V	rojo
GND	Negro
RX / D0	Blanco
TX / D1	Verde
D2	Amarillo
Restablecer, puedes mantenerlo desconectado.	Azul

• Programa de compilación y carga.

Abra el programa Arduino en la Demo. Luego, compílalo y cárgalo. Tenga en cuenta que el cable blanco se debe quitar al cargar el programa.

Para NUCLEO

• Conexión de hardware

Aquí, tomamos la placa de desarrollo NUCLEO-F103RB como ejemplo para ilustrar la aplicación. Conecte la placa de desarrollo al papel electrónico con un cable serie como se muestra en la siguiente tabla. Para obtener más información sobre esta placa de desarrollo, consulte el Apéndice.

Conexión entre NUCLEO-F103RB y 4.3inch e-Paper:

NUCLEO-F103RB	E-papel de 4.3 pulgadas
5V	rojo
GND	Negro
RX / D0	Blanco
TX / D1	Verde
D2	Amarillo
Restablecer, puedes mantenerlo desconectado.	Azul

• Programa de compilación y programación.

Abra el programa NUCLEO-F103RB en la demostración. Luego, compilarlo y programarlo.

Nota: Debe establecer el puente JP4 entre A y B.

Open103Z

• Conexión de hardware

Aquí, tomamos la placa de desarrollo Open103Z como ejemplo para ilustrar la aplicación. Conecte la placa de desarrollo al papel electrónico con un cable serie como se muestra en la siguiente tabla. Para obtener más información sobre esta placa de desarrollo, consulte el Apéndice.

Conexión entre NUCLEO-F103RB y 4.3inch e-Paper:

Open103Z	E-papel de 4.3 pulgadas
5v	rojo
GND	Negro
PA10	Blanco
PA9	Verde
PA11	Amarillo
Restablecer, puedes mantenerlo desconectado.	Azul

• Programa de compilación y programación.

Abra el programa Open103Z en la Demo. Luego, compilarlo y programarlo.

Protocolo de comunicación serial

Reglas básicas

Puerto serial

Este módulo de papel electrónico adopta la comunicación UART asíncrona de dúplex completo con velocidad de transmisión ajustable.

Formato de marco de comando

Mando	0xA5	0xXX XX	0xXX	0xXX …	0xCC 33 C3 3C	0xXX
Significado (Descripción)	Encabezado de cuadro(1 byte)	Longitud del marco [1](2 bytes)	Tipo de comando(1 byte)	Parámetro o datos(0 ~ 1024 bytes)	Extremo del marco(fijo 4 bytes)	Paridad(1 byte) [2]

[1] La longitud del cuadro se calcula por la longitud que comienza con el encabezado del cuadro y finaliza con el byte de paridad.

[2] El byte de paridad es el resultado final de la operación XOR en los bytes desde el encabezado del cuadro hasta el final del cuadro.

Secuencia de transmisión

Los datos del módulo se transmiten en la secuencia de bytes de la red, lo que significa que primero se envía el byte más alto y luego el byte más bajo. Por ejemplo, un parámetro, 0x1234, se transmite en dos partes: 0x12 se envía primero y luego 0x34.

Parámetros de comando

• Byte: 8 bits, byte único;

• Corto: 16 bits, dobles bytes;

• Dword: 32 bits, cuatro bytes;

• Cadena: la cadena de caracteres termina con «\ 0».

Definición de color

Este módulo de papel electrónico es compatible con pantalla gris de 4 niveles y 2 bits para cada píxel.

0x00: negro

0x01: gris oscuro

0x02: gris claro

0x03: blanco

Conjunto de comandos

Tabla de consulta de comandos

Funciones	Longitud del marco	Mando	Parámetro de comando	Descripciones
Control de sistema	0x0009	0x00	Nulo	Comando apretón de manos. Si el módulo está listo, devolverá un «OK».
	0x000D	0x01	Dword: Establecer la velocidad de transmisión en serie	Establecer la velocidad de transmisión en serie
	0x0009	0x02	Nulo	Devuelve el valor de velocidad de transmisión actual en formato ASCII
	0x0009	0x06	Nulo	Devuelve la información sobre el área de almacenamiento actualmente utilizada.0: NandFlash 1: MicroSD
	0x000A	0x07	Byte: establecer el área de almacenamiento	0x00: NandFlash0x01: MicroSD
	0x0009	0x08	Nulo	El sistema entra en modo de reposo
	0x0009	0x0A	Nulo	Actualizar y actualizar la pantalla a la vez
	0x0009	0x0C	Nulo	Devuelve la dirección de visualización actual0: Normal 0x01: 90 ° 0x02: 180 ° 0x03: 270 °
	0x000A	0x0D	Byte: establece la dirección de visualización	0x00: Normal0x01: 90 ° 0x02: 180 ° 0x03: 270 °
	0x0009	0x0E	Nulo	Biblioteca de fuentes de importación: 48MB
	0x0009	0x0F	Nulo	Imagen de importación: 80MB
Configuración de parámetros de visualización	0x000B	0x10	Byte0: color de primer planoByte1: color de fondo	Establecer el color del dibujo.
	0x0009	0x11	Nulo	Devuelve el color del dibujo actual.
	0x0009	0x1C o 0x1D (puede variar según el firmware)	Nulo	Obtener el tamaño de letra Inglés1: 32 puntos de matriz 2: matriz de 48 puntos 3: matriz de 64 puntos
	0x0009	0x1D	Nulo	Obtener el tamaño de fuente1: 32 puntos de matriz 2: matriz de 48 puntos 3: matriz de 64 puntos
	0x000A	0x1E o 0x1F (puede variar según el firmware)	Byte0: establece el tamaño de fuente en inglés	Establecer el tamaño de fuente en inglés0x01: matriz de 32 puntos 0x02: matriz de 48 puntos 0x03: matriz de 64 puntos
	0x000A	0x1F	Byte0: establece el tamaño de fuente	Establecer el tamaño de fuente0x01: matriz de 32 puntos 0x02: matriz de 48 puntos 0x03: matriz de 64 puntos
Dibujos basicos	0x000D	0x20	Short0: coordenada xShort1: coordenada y	Mostrar un punto en una coordinación dadaPredeterminado: color de primer plano
	0x0011	0x22	Short0: coordenada x0Short1: coordenada y0 Short2: coordenada x1 Short3: coordenada y1	Dibuja una línea
	0x0011	0x24	Short0: coordenada x0Short1: coordenada y0 Short2: coordenada x1 Short3: coordenada y1	Llenar un rectángulo
	0x0011	0x25	Short0: coordenada x0Short1: coordenada y0 Short2: coordenada x1 Short3: coordenada y1	Dibujar un rectángulo
	0x000F	0x26	Short0: coordenada x0Short1: coordenada y0 Short2: r radio	Dibuja un circulo
	0x000F	0x27	Short0: coordenada x0Short1: coordenada y0 Short2: r radio	Llenar un circulo
	0x0015	0x28	Short0: coordenada x0Short1: coordenada y0 Short2: coordenada x1 Short3: coordenada y1 Short4: coordenada x2 Short5: coordenada y2	Dibujar un tri-angulo
	0x0015	0x29	Short0: coordenada x0Short1: coordenada y0 Short2: coordenada x1 Short3: coordenada y1 Short4: coordenada x2 Short5: coordenada y2	Llenar un tri-angulo
	0x0009	0x2E	Nulo	Borrar la pantalla con color de fondo
Mostrar texto	0x0D + longitud de la cadena	0x30	Short0: coordenada xShort1: coordenada y Cadena: nombre de mapa de bits	Soporta fuente mixta en inglés y chino Longitud máxima de la cadena = 1024 – 4
Mostrar imagen(.bmp y .jpg solamente)	0x0D + longitud de la cadena	0x70	Short0: coordenada x0Short1: coordenada y0 Cadena: nombre de archivo .BMP	Soporte de archivo de mapa de bits: .BMP, .JPG
Secuencia de entrada UART (nuevo)	0x0D + longitud de la cadena	0x40	Cadena: nombre de archivo	Envíe un archivo a la tarjeta SD usando UART y especifique un nombre de archivo para guardar
Gestor de almacenamiento (nuevo)	0x09	0x50		Nand Flash borrado completo

Observaciones:

[1] La longitud de la cadena es la longitud del extremo de la cadena de caracteres con «\ 0», en la que se incluye el final «\ 0».

[2] El nombre de la imagen debe estar en caracteres en mayúsculas en inglés con una longitud inferior a 10 caracteres (el símbolo «.» Está incluido). Y la longitud de la cadena del nombre de la imagen debe tener menos de 11 caracteres, en los que se incluye el final «0».

Explicaciones de mando

Control de sistema

• Comando apretón de manos (0x00)

Después del encendido, puede enviar este comando al terminal para asegurarse de que el terminal esté listo y pueda recibir comandos o datos.

Ejemplo : A5 00 09 00 CC 33 C3 3C AC

Descripciones : Comando apretón de manos

• Establecer la velocidad de transmisión (0x01)

Después del encendido, la velocidad de transmisión predeterminada es 115200. Este comando se usa para establecer la velocidad de transmisión. Es posible que deba esperar 100 ms para que el módulo devuelva el resultado después de enviar este comando, ya que el host puede tardar un tiempo en cambiar su velocidad de transmisión.

Ejemplo : A5 00 0D 01 00 00 25 80 CC 33 C3 3C 0C

Descripciones : 0x2580: establezca la velocidad en baudios en 9600. El parámetro de la velocidad en baudios consta de 4 bytes, por lo que debe completar el resto por sí mismo.

• Lea la velocidad de transmisión actual (0x02)

Ejemplo : A5 00 09 02 CC 33 C3 3C AE

Descripciones : Lea la velocidad actual en baudios del sistema.

• Devuelve la información sobre el área de almacenamiento actualmente utilizada (0x06)

Ejemplo : A5 00 09 06 CC 33 C3 3C AA

Descripciones : cuando se devuelve 0x00, el área de almacenamiento utilizada actualmente es NandFlash interno; cuando devuelve 0x01, el área de almacenamiento actualmente utilizada es una tarjeta TF externa.

• Establecer el área de almacenamiento (0x07)

Configure el área de almacenamiento para seleccionar las ubicaciones de almacenamiento de la biblioteca de fuentes y las imágenes, ya sea que esté disponible la tarjeta TF externa o la NandFlash interna.

Ejemplo : A5 00 0A 07 00 CC 33 C3 3C A8

Descripciones : 0x00: establece el área de almacenamiento utilizada actualmente como NandFlash.

• Modo de suspensión (0x08)

El sistema entrará en el modo de suspensión y reducirá el consumo de energía del sistema con este comando. En el modo de suspensión, el indicador de estado está apagado y el sistema no responde ningún comando. Solo el borde ascendente en el pin WAKE_UP puede activar el sistema.

Ejemplo: A5 00 09 08 CC 33 C3 3C A4

Descripciones: cambiar el sistema al modo de suspensión.

• Actualizar (0x0A)

Actualizar y actualizar la pantalla en la pantalla. Después de que el host envíe el comando de dibujo, el sistema solo escribirá los datos relativos en la memoria de video interna, pero no actualizará la pantalla en la pantalla. Por lo tanto, debe ejecutar este comando cada vez que termine cada dibujo.

Ejemplo : A5 00 09 0A CC 33 C3 3C A6

Descripciones : Actualizar y actualizar la pantalla en la pantalla.

• Obtener la dirección de visualización (0x0C)

Ejemplo : A5 00 09 0C CC 33 C3 3C A0

Descripciones : Cuando devuelve 0, la pantalla está en la pantalla normal; cuando regrese 1 o 2, la visualización en la pantalla girará 180 °.

• Establecer la dirección de visualización (0x0D)

Establezca la dirección de la pantalla, solo se admite la rotación de 180 °.

Ejemplo : A5 00 0A 0D 01 CC 33 C3 3C A3, o, A5 00 0A 0D 02 CC 33 C3 3C A0

Descripciones : 0x01: La visualización en la pantalla cambiará de visualización normal a rotación de 180 °.

• Biblioteca de fuentes de importación (0x0E)

Importe los archivos de la biblioteca de fuentes desde la tarjeta TF al NandFlash interno. Los archivos de la biblioteca de fuentes incluyen GBK32.FON / GBK48.FON / GBK64.FON. El indicador de estado parpadeará 3 veces cuando la importación comience y finalice.

Ejemplo : A5 00 09 0E CC 33 C3 3C A2

Descripciones : Importar la biblioteca de fuentes.

• Importar imagen (0x0F)

Importe los archivos de imagen de la tarjeta TF al NandFlash interno. El indicador de estado parpadeará 3 veces cuando la importación comience y finalice.

Ejemplo : A5 00 09 0F CC 33 C3 3C A3

Descripciones : Importar las imágenes.

Configuración de parámetros de visualización

• Coloca el palet (0x10)

Establezca el color de primer plano y el color de fondo en el dibujo, en el cual el color de primer plano se puede usar para mostrar los dibujos y el texto básicos, mientras que el color de fondo se usa para borrar la pantalla.

Ejemplo : A5 00 0B 10 00 03 CC 33 C3 3C BD

Descripciones : 0x00: el color de primer plano está configurado en negro

0x03: el color de fondo se establece en blanco

• Obtener los datos del palet (0x11)

Ejemplo : A5 00 09 11 CC 33 C3 3C BD

Descripciones : por ejemplo, cuando devuelve «03», «0» significa que el color de primer plano es Negro y «3» significa que el color de fondo es Blanco.

• Obtenga el tamaño de fuente en inglés (0x1C o 0x1D, puede variar según la versión)

Ejemplo : A5 00 09 1C CC 33 C3 3C B0, o, A5 00 09 1D CC 33 C3 3C B1

Descripciones : Devuelve el índice del tamaño de letra inglés actualmente utilizado.

• Obtener el tamaño de fuente chino (0x1D)

Ejemplo : A5 00 09 1D CC 33 C3 3C B1

Descripciones : Devuelve el índice del tamaño de fuente chino utilizado actualmente.

• Establezca el tamaño de fuente en inglés (0x1E o 0x1F, puede variar según la versión)

Establezca el tamaño de fuente en inglés, actualmente admite una matriz de 32/48/64 puntos.

Ejemplo : A5 00 0A 1E 03 CC 33 C3 3C B2, o, A5 00 0A 1F 03 CC 33 C3 3C B3

Descripciones : 0x03: Establezca el tamaño de fuente en inglés en una matriz de 64 puntos

• Establecer el tamaño de fuente chino (0x1F)

Establezca el tamaño de fuente chino, actualmente admite una matriz de 32/48/64 puntos.

Ejemplo : A5 00 0A 1F 01 CC 33 C3 3C B1

Descripciones : 0x01: Establezca el tamaño de fuente chino en una matriz de 32 puntos

Dibujos basicos

• Dibuja un punto (0x20)

Mostrar un punto en una posición de coordinación especificada con color de primer plano.

Ejemplo : A5 00 0D 20 00 0A 00 0A CC 33 C3 3C 88

Descripciones : Mostrar un punto en la posición (0x0A, 0x0A) con color de primer plano.

• Dibuja una línea (0x22)

Dibuje una línea entre dos coordenadas de punto especificadas con color de primer plano.

Ejemplo : A5 00 11 22 00 0A 00 0A 00 FF 00 FF CC 33 C3 3C 96

Descripciones : Dibuje una línea entre las coordenadas del punto (0x0A, 0x0A) y (0xFF, 0xFF) con el color de primer plano.

• Rellena un rectángulo (0x24)

Rellene un rectángulo de acuerdo con dos coordenadas de punto con el color de primer plano, en el que estos dos puntos sirven como puntos diagonales del rectángulo.

Ejemplo : A5 00 11 24 00 0A 00 0A 00 FF 00 FF CC 33 C3 3C 90

Descripciones : rellene un rectángulo de acuerdo con las coordenadas del punto (0x0A, 0x0A) y (0xFF, 0xFF), en las que estos dos puntos sirven como puntos diagonales del rectángulo.

• Dibuja un rectángulo (0x25)

Dibuje un rectángulo de acuerdo con dos coordenadas de punto con el color de primer plano, en el que estos dos puntos sirven como puntos diagonales del rectángulo.

Ejemplo : A5 00 11 25 00 0A 00 0A 00 FF 00 FF CC 33 C3 3C 91

Descripciones : Dibuje un rectángulo de acuerdo con las coordenadas del punto (0x0A, 0x0A) y (0xFF, 0xFF), en las que estos dos puntos sirven como puntos diagonales del rectángulo.

• Dibuja un círculo (0x26)

Dibuja un círculo basado en la coordinación y el radio del centro dado.

Ejemplo : A5 00 0F 26 00 FF 00 FF 00 80 CC 33 C3 3C 0C

Descripciones : Dibuje un círculo con la coordinación central (0xFF, 0xFF) y el radio 0x80.

• Rellena un círculo (0x27)

Rellene un círculo basado en la coordinación y el radio del centro dado.

Ejemplo: A5 00 0F 27 00 FF 00 FF 00 80 CC 33 C3 3C 0D

Descripciones: rellene un círculo cuya coordinación central sea (0xFF, 0xFF) y el radio sea 0x80.

• Dibuja un tri-angulo (0x28)

Dibuja un tri-ángulo de acuerdo con tres coordenadas de puntos dadas.

Ejemplo : A5 00 15 28 00 0A 00 0A 00 20 00 80 00 80 00 FF CC 33 C3 3C 47

Descripciones : Las coordenadas de los tres puntos del tri-ángulo son (0x0A, 0x0A), (0x20, 0x80) y (0x80, 0xFF).

• Rellena un tri-angulo (0x29)

Rellene un tri-ángulo de acuerdo con tres coordenadas de puntos dadas.

Ejemplo: A5 00 15 29 00 0A 00 0A 00 20 00 80 00 80 00 FF CC 33 C3 3C 46

Descripciones: Las coordenadas de los tres puntos del tri-ángulo son (0x0A, 0x0A), (0x20, 0x80), (0x80, 0xFF)

• Borrar la pantalla (0x2E)

Borrar la pantalla con el color de fondo.

Ejemplo: A5 00 09 2E CC 33 C3 3C 82

Descripciones: Borrar la pantalla.

Mostrar texto

• Mostrar cadena de caracteres (0x30)

Mostrar una cadena de caracteres en una posición de coordinación especificada. Soporta pantalla mixta china e inglesa.

Ejemplo : A5 00 17 30 00 0A 00 0A C4 E3 BA C3 57 6F 72 6C 64 00 CC 33 C3 3C 9E

Descripciones : 0x0A, 0x0A: Esta es la posición de coordinación dada

0xC4E3: 你

0xBAC3: 好

0x57 6F 72 6C 64: Mundo

Después de ejecutar este comando, la pantalla mostrará el texto: 你好 Mundo

Cada cadena de caracteres debe terminar con un «0». Por lo tanto, debe agregar un «00» al final de la cadena C4 E3 BA C3 57 6F 72 6C 64.

UART input Stream (nuevo)

• Envía un archivo a la tarjeta SD usando UART (0x40)

Ejemplo : A5 00 12 40 50 49 43 37 2E 42 4D 50 00 CC 33 C3 3C EB

Descripciones :

50 49 43 37 2E 42 4D 50 son los códigos ASCII de “PIC7.BMP”. Después de que se ejecute este comando, todos los datos de UART se guardarán en la tarjeta SD y se guardarán como PIC7.BMP. Si la transmisión se detiene más de 1 s, esta función también se detendrá. Una vez que se haya enviado el archivo, se devolverán el tamaño del archivo y la comprobación de Xor y debe compararlos para verificar si el archivo se envió correctamente. Por último, si el archivo se envió correctamente, debe enviar el carácter ‘y’ para confirmar. Si el archivo es una imagen (.JPG o .BMP), debe configurar el área de almacenamiento en la tarjeta SD (A5 00 0A 07 01 CC 33 C3 3C A9) y luego usar el comando de visualización de imagen para mostrarlo. El comando del flujo de entrada de UART no se ve afectado por la configuración del área de almacenamiento. Los archivos solo se guardarán en la tarjeta Micro SD.

Mostrar imagen

• Mostrar mapa de bits (0x70)

Antes de ejecutar este comando, asegúrese de que el archivo de mapa de bits que desea visualizar esté almacenado en el área de almacenamiento (tarjeta TF o NandFlash interna).

Ejemplo : A5 00 16 70 00 00 00 00 50 49 43 37 2E 42 4D 50 00 CC 33 C3 3C DF

Descripciones : Posición de coordinación de inicio de imagen: (0x00, 0x00)

0x50 49 43 37 2E 42 4D 50: Nombre de mapa de bits: PIC7.BMP

Cada cadena de caracteres debe terminar con un «0». Por lo tanto, debe agregar un «00» al final de la cadena 50 49 43 37 2E 42 4D 50.

El nombre del archivo de mapa de bits debe estar en caracteres en inglés en mayúsculas. Y la longitud de la cadena del nombre del mapa de bits debe tener menos de 11 caracteres, en los que se incluye el final «0». Por ejemplo, PIC7.BMP y PIC789.BMP son nombres de mapa de bits correctos, mientras que PIC7890.BMP es un nombre de mapa de bits incorrecto.

Librería para arduino

Descargar–> epd

Software para Pc

 

---

Tal vez pueda interesarte proyectos en arduino, pic, robótica, telecomunicaciones, suscribete en http://www.youtube.com/user/carlosvolt?sub_confirmation=1 mucho videos con código fuentes completos y diagramas

---

SUSCRIBETE A NUESTROS BOLETINES, RECIBE EN TU CORREO LAS NOTICIAS MÁS DESTACADAS, SÓLO INGRESANDO TU CORREO ELECTRÓNICO

Correo Electrónico *

---

rogerBit necesita de tu ayuda para seguir existiendo :-)

---

VIDEOS RECOMENDADO

En esta entrada veremos un proyecto de IoT, con el apoyo de la empresa Ubidots, pueden visitar la página en https://ubidots.com/?utm_source=youtube&utm_medium=referral&utm_campaign=carlosvolt

Y registrase tiene un periodo de prueba gratis de 30 días, donde podrán hcer un uso completo de la plataforma.

En este proyecto vamos a subir datos a los servicio en la nube de ubidots. Usaremos un arduino uno, tambien un módulo ethernet para lograr la conexíon, y un display oled donde visualizaremos la temperatura.

Código fuente

// * Incluimos las siguientes librerías
#include <Ethernet.h>
#include <SPI.h>
#include <UbidotsEthernet.h>
#include "DHT.h"
#include "U8glib.h"
U8GLIB_SH1106_128X64 u8g(U8G_I2C_OPT_NONE);  // I2C / TWI // Se habilita esta linea según el display a a usar en este caso el driver SH1106 
#define DHTPIN 2     // Pin digital al caual vamos a conectar el sensor de temperatura

// Tipo de sensor que vamos a usar
#define DHTTYPE DHT11   // DHT 11
DHT dht(DHTPIN, DHTTYPE);
// Parámetros para el servidor de Ubidots.*/
char const * TOKEN = "BBFF-k3bid88HLUIzAbEXYKIZqrgATC0qM9"; // Token asignado por Ubidots
char const * VARIABLE_LABEL_1 = "temperatura_dht"; // Asigna una etiqueta de variable única para enviar los datos
char const * VARIABLE_LABEL_2 = "humedad_dht"; // Asigna una etiqueta de variable única para enviar los datos de la humedad
int temperatura = 0;
int humedad = 0;
/* Dirección MAC para el módulo ethernet */
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };

Ubidots client(TOKEN);

void setup() {
  Serial.begin(9600);
  //Inicializa el sensor de temperatura
  dht.begin();
  /* Inicializa la conexión Ethernet */
  Serial.print(F("Inicializando conexión ethernet..."));
  if (!Ethernet.begin(mac)) {
    Serial.println(F("ops hubo un problema"));
  } else {
    Serial.println(Ethernet.localIP());
  }
  // Esperamos un tiempo para el módulo arranque
  delay(2000);
  Serial.println(F("PLaca ethernet lista!!!"));
}

void loop() {

  Ethernet.maintain();
    float valor_temperatura = dht.readTemperature();// Leemos la temperatura en grados celsius
  float valor_humedad = dht.readHumidity();//Leemos la humedad
  temperatura = valor_temperatura;
  humedad = valor_humedad;
  //Impimimos estos valores en el terminal serial
  Serial.print("Temperatura:");
  Serial.println(valor_temperatura);
  Serial.print("Humedad:");
  Serial.println(valor_humedad);
  /* Enviando datos a Ubidots*/
  client.add(VARIABLE_LABEL_1, valor_temperatura);
  client.add(VARIABLE_LABEL_2, valor_humedad);
  client.sendAll();
  //Llamamos a nuestro display para que muestre los valores obtenidos
      u8g.firstPage();  
  do {
    draw();
  } while( u8g.nextPage() );

  //Esperemos 5 segunsdo antes de volver a subir otro datos a Ubidots
  delay(5000);
}

void draw(void) {
  u8g.setFont(u8g_font_unifont);
  //Veremos en pantalla los valores de Temperatura y humedad en la posición asignada
  u8g.setPrintPos(0, 20);
  u8g.print("Temperatura:");
  u8g.print(temperatura);
  u8g.setPrintPos(0, 40); 
  u8g.print("Humedad:");
  u8g.print(humedad);
}

Materiales

Escudo ethernet

Nuestro escudo ethernet será necesario, para subir datos a ubidots.com y también para mostrar datos en nuestra red local, sólo debemos abrir algún navegador web y escribir la ip que allá asignado nuestro router, eso lo podemos ver en el terminal serial. Una de las mejoras que se hará a futuro es agregar esta información en el display.

Arduino uno

Podemos usar el arduino uno o el arduino mega, pero observen el código fuente poque hay que hacer una leve modificación, al mismo según el arduino a usar. Nuestro arduino es el cerebro de todo el proyecto es quien se encargará de tomar lecturas del sensor y procesar estas señales para poder verlas en el display, el terminal serial, el control del escudo ethernet, y proveerá de la alimentación a todo el circuito.

Display Oled sh1106

Se trata de un módulo de pantalla OLED monocromática DE 128×64 puntos con interface I2C .Que presenta varias ventajas en comparación con pantallas LCD, y podemos destacar su alto brillo, un muy buen contraste, un ángulo de visión más amplio, y bajo consumo de energía. ES compatible con Arduino Rasberry Pi y micro controladores PIC entre otros. Trabaja con niveles lógicos de 3.3V a 5V tiene un angulo de visión mayor a los 160 grados. el Tamaño de la pantalla es de 1,3 pulgadas. Se alimenta con un voltaje de 3.3V a 5V Se lo puede usar en aplicaciones como relojes inteligentes, MP3, termómetros, instrumentos, y proyectos varios, etc.

Librería

U8glib

Características

Interface: I2C(3.3V / 5V logic level)

Resolution: 128 x 64

Angle of view: >160 degree

Display color: Blue

Display size: 1.3 inch

Driver IC: SH1106

Power supply: DC 3.3V~5V

Operating temperature: -20~70’C

Application: smart watch, MP3, thermometer, instruments, DIY projects, etc.

Librería Ubidots Ethernet

ubidots-arduino-ethernet-master

Sensor DHT11

Circuito

Instalación librería para arduino

Para subir datos a ubidots con nuestra placa arduino y ethernet, deberemos instalar esta librería.

Pasos para subir datos a Ubidots

Nos dirigiremos a dispositivos y click en «dispositivos».

Click en «add new device».

Click en «Ethernet» y luego en «Blank».

Y escribimos un nombre para nuestro dispositivo, y lo creamos con este botón.

Hacemos click en el dispositivo.

La nombramos según la etiqueta que le pusimos en el código fuente, para datos de temperatura.

Agregamos otra variable «normal». La nombramos con la otra etiqueta para obtener la humedad.

Y como vemos nuestro dispositivo ya tiene dos variables distintas.

Y vamos a «agregar nuevo witget». Elegimos «Thermometer».

Agregamos una variable.

Y en «Label» le ponemos el mismo nombre de la etiqueta que en el código fuente, para la temperatura.

En «nombre» le ponemos un nombre descriptivo, del tipo de datos que vamos a recolectar, aceptamos.

Y hacemos click en el dispositivo creado en este caso «arduino-ethernet».

Ya podemos ver la temperatura.

Agregamos otro «witget», en este caso es un «Line Chart».

En «Label» ponemos la misma etiqueta.

En «Nombre» ponemos un nombre descriptivo. Aceptamos los cambios.

Turno del widget para la humedad. Elegimos «Gauge».

Agregamos una etiqueta que nos debe coincidir con con la que pusimos en el código fuente de arduino, y también un nombre descriptivo. Los valores máximos y mínimos los dejamos tal cual.

Otro «Line chart» para el histórico de humedad es recomendable agregar, Los pasos para su creación son los mismo que ya vimos.

Podemos acomodar los widget como nos quede más cómodo.

Eventos

Iremos a «Crear un evento».

Click en «Seleccionar Variable»

Elegimos «Mayor que» para que nos notifique en el caso de un exceso de temperatura.

Y le asignamos el valor máximo antes de una notificación. Podemos poner que tiempo puede permanecer en ese valor antes del envío de la notificación.

Acá podemos elegir que tipo de notificación deseamos recibir.

Si elegimos, por ejemplo, notificación por correo electrónico, agregamos la dirección donde recibiremos la alerta.

También podemos personalizar el mensaje, según lo que nos convenga.

Y en «default token» hacemos click en «Click to show», y copiamos el token que debemos agregar a nuestro código fuente.

También podemos agregar, modificar y borrar otros token.

Tal vez pueda interesarte proyectos en arduino, pic, robótica, telecomunicaciones, suscribete en http://www.youtube.com/user/carlosvolt?sub_confirmation=1 mucho videos con código fuentes completos y diagramas

SUSCRIBETE A NUESTROS BOLETINES, RECIBE EN TU CORREO LAS NOTICIAS MÁS DESTACADAS, SÓLO INGRESANDO TU CORREO ELECTRÓNICO

VIDEOS RECOMENDADO

En este tutorial encenderemos un foco a través de los servicios en la nube de Ubidots, además tendrá un sistema, para detectar si el foco si ha quemado y nos enviará una alerta, por medio de un SMS, advirtiendo que el foco no ha encendido. Se incluye el código fuente y el circuito.

Visita https://ubidots.com/ para obtener mas información de los servicios de Ubidots, registrate y prueba los servicios en la nube durante 30 días gratis.

Código fuente

// * Incluimos las siguientes librerías
#include <Ethernet.h>
#include <SPI.h>
#include <UbidotsEthernet.h>

// Parámetros para el servidor de Ubidots.*/
char const * TOKEN = "BBFF-k3bid88HLUIzAbEXYKIZqrgATC0qM9"; // Token asignado por Ubidots
char const * DEVICE_LABEL = "arduino-ethernet"; //Asignar la etiqueta única del dispositivo
char const * VARIABLE_LABEL_PIN8 = "pin"; // Asigna una etiqueta de variable única para recibir los datos
char const * VARIABLE_LABEL_PHOTO = "photo"; // Asigna una etiqueta de variable única para enviar los datos del fotoresistor
int fotoResistor = A0;
int sensorLuz=0;
int luz=8;
/* Dirección MAC para el módulo ethernet */
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };

Ubidots client(TOKEN);

void setup() {
  Serial.begin(9600);//velocidad del puerto serial
  pinMode(luz, OUTPUT);
   Serial.print(F("Inicializando conexión ethernet..."));
  if (!Ethernet.begin(mac)) {
    Serial.println(F("ops hubo un problema"));
  } else {
    Serial.println(Ethernet.localIP());//Nos muestra la dircción ip local
  }
  // Esperamos un tiempo para el módulo arranque
  delay(2000);
  Serial.println(F("PLaca ethernet lista!!!"));
}

void loop() {
  Ethernet.maintain();
  
  float valor = client.getValue(DEVICE_LABEL, VARIABLE_LABEL_PIN8);// * Obtenemos el último valor de una variable * /
  
  /* Mostramos el valor obtenido */
  Serial.print("El valor recibido es:  ");
  Serial.println(valor);
  //Se evalua el valor enviado desde ubidots
  if(valor==1){
    digitalWrite(luz, HIGH);
    delay(2000);
  fotoR();
  }
  if(valor==0){
    digitalWrite(luz, LOW);
    }
  delay(1000);
}
void fotoR(){
  //delay(1000);
   //Leemos el fotoresitor 
  sensorLuz =analogRead(fotoResistor);
  Serial.print("Valor Foto Resisitor: ");
  Serial.println(sensorLuz);
  if(sensorLuz>50){
  //Enviamos el valor del sensor del foto resistor
  client.add(VARIABLE_LABEL_PHOTO, sensorLuz);
  client.sendAll();  
  }
}

Circuito

Materiales

Módulo Fotorresistencia

Este módulo contiene una fotorresistencia, la cual es una resistencia variable dependiente de la cantidad de luz en su entorno. En la oscuridad, su resistencia es muy alta, a veces hasta 1 MΩ, pero cuando el sensor LDR se expone a la luz, la resistencia se reduce drásticamente, incluso a unos pocos ohm, dependiendo de la intensidad de la luz.

El sensor LDR es ampliamente utilizado en cámaras, lámparas de jardín y calle, detectores, relojes, luces automáticas y un sinfín de aplicaciones interesantes. Los valores de su resistencia, sensibilidad, coeficiente de temperatura y su curva de voltaje-corriente dependen directamente de la cantidad de luz que recibe el sensor.

Módulo relay

El manejo de un módulo relee o relay es muy sencillo y nos permite controlar el encendido y apagado de cualquier aparato que se conecte a una fuente de alimentación eléctrica externa. El relee hace de interruptor y se activa y desactiva mediante una entra de datos. Gracias a esto podemos controlar el encendido de cualquier aparato

Escudo ethernet

Nuestro escudo ethernet será necesario, para subir datos a ubidots.com y también para recibirlos.

Tal vez pueda interesarte proyectos en arduino, pic, robótica, telecomunicaciones, suscribete en http://www.youtube.com/user/carlosvolt?sub_confirmation=1 mucho videos con código fuentes completos y diagramas

SUSCRIBETE A NUESTROS BOLETINES, RECIBE EN TU CORREO LAS NOTICIAS MÁS DESTACADAS, SÓLO INGRESANDO TU CORREO ELECTRÓNICO

VIDEOS RECOMENDADO

En este artículo revisaremos el comutador wifi WK4T, con el aporte de ICStation,

pueden adquirir este producto en http://www.icstation.com/110v-230v-wifi-relay-switch-multi-channel-remote-control-network-relay-antenna-p-10966.html

Importante:
Estimados ICstation les da un descuento por ser suscriptores del canal, por favor leer esto
15% de descuento para cualquier artículo, utilice el código «Carics» durante el pago
No hay un tiempo limitado, siempre válidos, se puede usar en cualquier momento. También podría ser utilizado en artículos con descuento.

Código: Carics
Cantidad Descuento: 15% de descuento
Max Uso: 1 (uno para por usuario)
Límite de cantidad: 300
El código lo introducen cuando estén por finalizar la compra y se verá reflejado inmediatamente.

Introducción del producto:

1>. Tamaño: 116 * 92 * 42 mm

2>. Longitud de la antena: 10 cm

3>. Voltaje de funcionamiento: CA 110V-230V

4>. Puerto de salida: NO NC; Interruptor mecánico de salida de puerto

5>. Carga nominal: CA 0-250V / 8A 1400W; DC 0-30V / 8A 200W

6>. Modo de control: control de red wifi, soporte de red celular 2G / 3G / 4G

7>. Campo de aplicación: Soporte de Android, Apple, control de teléfono celular Wechat

Imagen del producto

Configuración Ewelink

para poder utilizar este dispositivo, vamos a necesitar instlar de la tienda playstore, la aplicación Ewelink.

La abrimos.

Aceptamos los términos.

Elegimos nuestro país

E introducimos nuestra dirección de correo electrónico, si es que ya estamos registrados con anterioridad, y también la contraseña.

Apretamos en el dispositivo el siguiente botón, durante algunos segundos.

Y click en siguiente.

Introducimos la contraseña de nuestra red wifi.

Click en ok.

Y luego en permitir.

Esperemos algunos segundos.

Click en terminado.

Y ha continuación en «Lo tengo».

Listo nuestro dispositivo, ya está configurado para funcionar.

Tal vez pueda interesarte proyectos en arduino, pic, robótica, telecomunicaciones, suscribete en http://www.youtube.com/user/carlosvolt?sub_confirmation=1 mucho videos con código fuentes completos y diagramas

SUSCRIBETE A NUESTROS BOLETINES, RECIBE EN TU CORREO LAS NOTICIAS MÁS DESTACADAS, SÓLO INGRESANDO TU CORREO ELECTRÓNICO

VIDEOS RECOMENDADO

En esta entrada veremos como actualizar el módulo GSM A6

El módulo GSM A6 es un módulo que nos permite reliazar, llamadas telefónicas, enviar SMS, y tambien conectarnos a internet para subir datos de sensores a la red, ideal para IoT (Internet de las cosas).

Este módulo ha sido desarrollado por la empresa Ai Thinker, más conocido por los módulo esp8266 y el esp32 y otros modulos GSM y GPS.

El módulo A6 es bastante fácil de usar para un proyecto pequeño, se puede alimentar a través de USB (5 voltios y mínimo 2 Amperes, es muy importante respetar el valor de corriente).

Con esta actualización solucionaremos los siguientes problemas según el fabricante:

Versión 201700901:

• El módulo no responde después de que el servidor se desconecta
• El módulo responde al error de respuesta de evento cerrado Directo a + cipsend no puede enviar 0
• Los SMS deben ser recibidos por AT + CPMS = «SM», «SM», «SM»
• Encienda usando el almacenamiento de 3 tarjetas, pero el predeterminado es el almacenamiento de mi SMS elimina uno, pero elimina dos al consultar, reiniciar solo elimina uno
• IP está utilizando AT + CGACT = 1,1 no se puede consultar
• Optimice la conexión del nombre de dominio de DNS, de modo que la tasa de éxito de usar directamente AT + CIPSTART sea mayor
• Optimice el esquema de recepción de datos tcpip para que los caracteres especiales enviados por el servidor también puedan recibirse en el modo no transparente.
• Iniciar salida tipo de letra Inic … tipo de letra, inicialización sms tipo de letra READY
• La primera entrada de comando en el encendido no responde, se utiliza para ajustar la velocidad en baudios (el valor predeterminado es 115200), y hay una respuesta del segundo comando.
• Versión 20170908: Se corrigió el uso de AT + CIPSTART = «TCP», «xxx, xxx, xxx, xxx», xx; después de más de cuatro veces que el servidor no pudo conectarse, debe reiniciarse para continuar la conexión.
• Versión 20171127: Se corrigió un error por el cual UDP no podía ingresar transmisión transparente.
• Se agregó AT + CCLK? Acceso directo al tiempo de la estación base

PinOut módulo A6

Adaptador Usb Serial

Probar la conexión del módulo

El módulo tiene dos puertos serie: uno para enviar comandos AT y otro para actualizar el firmware.

Use un convertidor USB-serie conectado a GND / U_TXD / U_RX a su computadora.

Puede utilizar la herramienta proporcionada por AI Thinker para enviar / recibir comandos hacia el módulo.

Una vez que el dispositivo se alimente con el cable USB o el pin de 5 V (2Amps mínimo), presione el botón de encendido algunos segundos para iniciar.

Actualización de firmware

Antes de actualizar el firmware del módulo vamos a ver si realmente es necesario, con la herramienta del fabricante llamada AI-Thinker Serial Tool, debemos seleccionar el puerto de comunicaciones correcto y esto puede variar de una pc a otra, en este ejemplo es el COM14.

Ejecutamos el comando ATI y nos va a motrar la versión que tiene cargado el módulo A6

No olvidemos que debemos conectar los pines  GND / U_TXD / U_RX al adaptador serial como se ve en la siguiente imagen.

Nota: Podemos alimentar el módulo desde el adaptador serial, pero es recomendable hacerlo desde el puerto micro usb que tiene incorporado el módulo. También recomiendo no colocar el chip GSM al módulo, porque intentará registrase a la red y esto consume bastante energía y puede llegar a traer inconvenientes con la actualización.

Como hemos visto en la anterior imagen el firmware que trae es el del 2016, el último que ha publicado el fabricante corresponde al 2017, en este caso podemos actualizar, con la última versión.

Para actualizar vamos a necesitar otro programa, llamado AI-Thinker GSM&GPS Download Tool (no olvides cerrar AI-Thinker Serial Tool, esto es muy importante para no tener conflictos al estar ocupando el puerto serial).

Recordemos cambiar los pines de posición U_TXD / U_RX  por HTXD / HRXD según la siguiente imagen

Haremos click en los tres puntos al final de FWH, nos va permitir seleccionar el archivo del firmware y simplemente hacemos click en abrir.

Esperamos a que el programa detecte automáticamente el puerto COM en mi caso el 14. La detección puede demorar entre 30 segundos a un minuto.

Hacemos click en «Start» y esperamos a que se complete todo el proceso que dura menos de 30 segundos, cerramos el programa.

Ahora verificaremos si la versión del firmware a cambiado, para ello cambiamos nuevamente la posición los cables, y abrimos nuevamente el programa AI-Thinker Serial Tool y enviamos el comando ATI, debería aparecernos la nueva versión del 2017.

Descargar firmware y herramientas para actualizar

Firmware y tool

SUSCRIBETE A NUESTROS BOLETINES, RECIBE EN TU CORREO LAS NOTICIAS MÁS DESTACADAS, SÓLO INGRESANDO TU CORREO ELECTRÓNICO

VIDEOS RECOMENDADO

En este video revisaremos la placa educativa micro:bit Go, gentiliza de dfrobot, la pueden adquirir en el siguiente link https://www.dfrobot.com/product-1625.html

En este video aprenderemos a como configurar la tarjeta micro:bit, desde una pc por cable micro usb y también con un smartphone por bluetooth con la aplicación que nos permite cargarle el código.

¿Que es micro:bit?

micro:bit es un microcontrolador de bolsillo diseñado para niños y principiantes que aprenden a programar, lo que les permite incorporar ideas en juegos digitales de bricolaje, proyectos interactivos y robótica. micro:bit viene con una variedad de módulos incorporados, incluido una Matriz LED de 5×5 (también compatible con detección de luz), 2 botones programables, detector de movimiento, brújula y módulo Bluetooth® Smart. Además, puede conectar más módulos, como un servomotor , las luces LED RGB a través de cinco anillos de E / S o 20 conectores.

Y aquí viene el paquete micro: bit Go , un kit de inicio sobre la marcha con cable USB , 2 baterías AAA y soporte de batería , lo que le permite cargar el programa y transportarlo justo después del desempaquetado.
micro: bit se puede programar con Microsoft Blocks Editor a través de un editor gráfico o un editor de JavaScript. El Microsoft Blocks Editor está disponible en Windows, macOS, IOS y Android, y admite la programación inalámbrica a través de dispositivos móviles.

CARACTERISTICAS

• Una variedad de módulos a bordo
• Expandible para sensores o actuadores adicionales
• Editor gráfico de arrastrar y soltar
• Carga de programas fácil y sin problemas
• Carga inalámbrica de programación Bluetooth
• Comunicación inalámbrica bluetooth

ESPECIFICACIÓN

• Microprocesador: CPU ARM® Cortex M0 de 32 bits
• Una matriz de 5×5 LED con 25 LEDs rojos para iluminar. Cada LED es programable individualmente y puede mostrar patrones animados, texto de desplazamiento y caracteres alfanuméricos
• Dos botones programables. El micro: bit puede detectar cualquiera de sus dos botones que se presionan y no se presionan, y se puede programar para que actúe al respecto o envíe la información a otro dispositivo. Úsalos como un controlador de juegos o controla la música en un teléfono inteligente.
• Detector de movimiento incorporado o acelerómetro digital 3-AXIS que puede detectar movimiento y avisar a otros dispositivos que está en movimiento. Mide en 3 ejes, X, Y, Z, y envía los datos en mili-gs. El micro: bit puede reaccionar a estos datos y decirle a otros dispositivos que se está moviendo. El dispositivo también detectará un pequeño número de acciones estándar, por ejemplo, sacudidas, inclinación y caída libre. Convierte el micro: bit en un nivel de burbuja. Úsalo para juegos activados por movimiento. Haz que tu micro: bit se ilumine cuando algo se mueve.
• Una brújula incorporada , un magnetómetro 3D para detectar en qué dirección está orientado y su movimiento en grados. Estos datos pueden ser utilizados por el micro: bit en un programa o ser enviados a otro dispositivo. El magnetómetro también podría detectar la presencia de ciertos metales e imanes.
• Tecnología Bluetooth® Smart (anteriormente llamada Bluetooth Low Energy) para comunicarse de forma inalámbrica con otros dispositivos Bluetooth Smart e intercambiar datos y comandos. Conecte el micro: bit a otros micro: bits, dispositivos, teléfonos, tabletas, cámaras y objetos de uso diario. Juega, comparte creaciones o une fuerzas para crear obras maestras multi-micro: bit. Toma una selfie. Pausa un DVD o controla tu lista de reproducción.
• Entrada y salida de cinco anillos (E / S), incluida la alimentación (PWR) y tierra (GRD). PWR, GRD, E / S x 3. Cada anillo de E / S se puede programar para que sea analógico o digital. Los anillos son adecuados para pinzas de cocodrilo o enchufes tipo banana de 4 mm, lo que significa que se puede conectar un sensor externo para medir cosas como la temperatura, la humedad y la proximidad a otros dispositivos. El micro: bit lee los valores del sensor y actúa sobre ellos o los envía a otro dispositivo. El micro: bit también puede enviar comandos de control a los anillos, que podrían usarse para controlar cosas como un motor o un robot. Los anillos PWR y GRD suministran 3 voltios y podrían utilizarse para alimentar un dispositivo separado.
• Conector de borde: 20 pines, paso de 1,27 mm y extensión de 7,62 mm desde el borde de la placa adecuado para conectores estándar. Esto permite que el micro: bit se conecte a otro dispositivo, por ejemplo, Arduino, Galileo, Kano y Raspberry Pi a través de un conector estándar.
• Controlador micro-USB : está controlado por un procesador independiente y presenta el micro: bit a una computadora como una tarjeta de memoria. Esto significa que el programa se puede arrastrar al micro: bit de la misma manera que un archivo se arrastra a una tarjeta de memoria.
• LED del sistema x 1 (amarillo)
• Interruptor de pulsador del sistema x 1
• Tamaño: 43 × 52 mm / 1.7 * 2.04 pulgadas (neto). 105x55x30 mm / 4.1×2.2×1.2 pulgadas (con paquete)
• Peso del microcontrolador: 8g

Ingresamos a esta url. Click en «vamos a programar».

Click en «New Projets».

Conectamos nuestra micro:bit a la pc. Veremos una secuencia de de luces al iniciar por primera vez.

Aparecerá en nuestra pc una unidad de disco llamada «microbit».

Arrastramos el archivo generado a la unidad.

Esperamos a que termine de cargar.

y ya podemos ver el programa funcionando en nuestra micro:bit.

Como cargar un programa a nuestra micro:bit, desde un smartphone por bluettooth

Vamos a instalar la aplicación micro:bit desde play store, y lo abrimos

Click en ok.

Click en «OK»

Click en «Connet»

Apretamos los 2 botones más el botón de reset, hasta que se enciendan todos los led´s, y soltamos los botones.

Click en «Pair a new micro:bit».

Click en «OK»

Click en «Permitir» para activar el bluetooth.

Click en «Next»

Copiamos el patrón generado por nuestro micro:bit.

Click en «Pair»

Click en «OK»

Click en «Create code»

Click en «Led’s Code.

Descargamos el archivo.

Click en «Flash».

Click en «OK».

Aparecerá este símbolo en nuestro micro:bit.

Esperamos a que se suba el programa.

Ya podemos ver nuestro programa funcionando.

Tal vez pueda interesarte proyectos en arduino, pic, robótica, telecomunicaciones, suscribete en http://www.youtube.com/user/carlosvolt?sub_confirmation=1 mucho videos con código fuentes completos y diagramas

SUSCRIBETE A NUESTROS BOLETINES, RECIBE EN TU CORREO LAS NOTICIAS MÁS DESTACADAS, SÓLO INGRESANDO TU CORREO ELECTRÓNICO

VIDEOS RECOMENDADO