Control de 8 salidas mediante comunicación serie. Arduino controla LEDs y ESP-12 Nodemcu controla Arduino.

El ESP-12 va a estar conectado a Internet mediante wifi y, uilizando un bot de telegram, apagará y encenderá los LEDs. Los comandos serán los mismos que en los proyectos anteriores.

De momento queda aparcado.
Pongo los códigos del ESP-12 que funcionan con el bot. No se si a otras personas les funcionará porque hace algún tiempo que lo hice y casi he olvidado el procedimiento.

En cualquier caso, cuando lo retome haré un bot nuevo porque voy a compartir sus códigos.

Creo que quien lo utilice debería hacer lo que yo y conectar el ESP-12 a una red de invitados para que no pueda acceder a la LAN.

Está sacado de otro proyecto, ya no recuerdo de donde lo saqué, pero será sencillo encontrarlo con los comentarios que tiene. Recuerdo que estaba bien documentado y me costó poco hacerlo funcionar.

Código:
//Alarma con esp8266 Nodemcu mini y sensor radar RCWL-0516
//Activación y notificación con Telegram
        // ¡¡¡¡¡¡USAR CON LIBRERIA ARDUINOJSON VERSION 5.13.5!!!!!
//En IDE ir a Programa->Incluir librería->Gestionar librerias->Arduinojson->seleccionar version


//
//

/*
 * https://forum.arduino.cc/index.php?topic=578384.0
 * http://www.jopapa.me/telegramesp8266.html
 * http://www.jopapa.me/alarmamicroondas2.html
 */

/*
 * imbita2 ya le da la IP 192.168.1.188 al ESP8266
 */

/*
 * Este funciona bien
 * Escribiendo en el chat On
 *  responde:Alarma activada y cada 1/2 segundo escribe Alarma en bibilioteca
 * Escribiendo en el chat Off
 *  responde Alarma desactivada
 */


#include "CTBot.h"   //Libreria para Telegram version 1.4.0
CTBot myBot;
String ssid = "imbita2";   
String pass = "qwertyuiop";
//Poner tu Telegram BOT TOKEN
String token = "1005110195:AAHskbRUYrXig7Hy5nqbguJLeXS6zfnG_M4";  
boolean alarma = false;
boolean activa = false;   //Estado de la alarma
long id=14322944;  //chat_id
void setup() {
Serial.begin(115200);
myBot.wifiConnect(ssid, pass);
myBot.setTelegramToken(token);
pinMode(2,OUTPUT);    //LED que confirma alarma activa
pinMode(D3, INPUT);  //Para leer el OUT del RCWL-0516
digitalWrite(2, HIGH); //LED apagado
// ¿Todo va bien?
if (myBot.testConnection())
  Serial.println("\nConexion OK");
else
  Serial.println("\nConexion fallida");
}

void loop() {
// almacena mensaje telegram recibido
TBMessage msg;
myBot.getNewMessage(msg);

if ((msg.text)=="On"){
  digitalWrite(2, LOW);
  activa = true;
  myBot.sendMessage(msg.sender.id, "Alarma activada"); 
}
if ((msg.text)=="Off"){
  digitalWrite(2, HIGH);
  activa = false;
  myBot.sendMessage(msg.sender.id, "Alarma desactivada"); 
}

alarma = digitalRead(D3);
if ((alarma == HIGH) && (activa == true)) {
  myBot.sendMessage(id, "Alarma en biblioteca");
  delay(500);  //evita repetición notificación
}
delay(50);
}

Control de 8 salidas mediante comunicación serie. Parte 2-2 arduinos-

Diseño en tinkercad (no funciona la conexión serie USB y por lo tanto los LEDS ni se encienden ni se apagan), aunque no funciona en virtual, se puede ver como se conecta. https://www.tinkercad.com/things/9lX4BaCdO4f-control-de-8-salidas-mediante-comunicacion-serie-p2

En dispositivos reales si funciona.

He intentado poner la librería que tiene el propio tinkercad (https://tinkercad.zendesk.com/hc/en-us/community/posts/115008544848-adding-library-for-arduino) pero tampoco funciona. Dejaré el tinkerad como ejemplo de montaje.

Primer Arduino (conectado a los LED):

Código:
/*
   Interface csca (Conexión Serie Con Arduino)
   va a conectarse con el arduino del USB
   utilizando la conexión serie csca
   Es similar al anterior pero cambiando Serial por csca
   enciende y apaga correctamente pero no termino
   de enviar correctamente el estado
   para empezar no se sincroniza hasta varios intentos
   después de haber cambiado
   y además:
    los 4 bits de mayor peso son 0011
    los 4 bits de menor peso se corresponden hasta el 7
    a partir de que se activa el bit del 8 comienza a fallar

   Comandos:
    s: estado ->devuelve un byte con el estado de cada led
    e:  encender  -> enciende el bit correspondiente al número
    a:  apagar  ->apaga el bit correspondiente...
   en la próxima version haré un
    aa: apagar todos
*/

/*
   Voy a escribir el estado como dos bytes hexadecimales enviando
   los caracteres corrspondientes. 1º H 2º L
*/
#include<SoftwareSerial.h>
SoftwareSerial csca(11, 2); // RX, TX csca; Comunicacion Serie Con Arduino
byte i;//la pongo global para que le asigne un espacio de memoria ya que la utilizo mucho
void setup() {
  // put your setup code here, to run once:
  csca.begin(57600);
  while (!csca);
  for (i = 0; i < 8; i++)
    pinMode(i + 3, OUTPUT);
  apagatodo();//lo voy a hacer ya para apagar todo al comienzo
}
void apagatodo() {
  for (i = 0; i < 8; i++)
    digitalWrite(i + 3, LOW);
}
void enviaestado() {
  byte estado, miniestado;
  char caracterL, caracterH;
  for (i = 0; i < 8; i++)
    bitWrite(estado, i, digitalRead(i + 3));
  csca.print("S");
  miniestado = estado & 0x0F;//solo deja los 4 bits de menor peso
  if (miniestado <= 9)
    caracterL = '0' + miniestado;
  else
    caracterL = 'A' + miniestado - 10;
  //solo puede ser de 0 a 9 ó de A a F
  estado = estado >> 4;
  miniestado = estado & 0x0F;
  if (miniestado <= 9)
    caracterH = '0' + miniestado;
  else
    caracterH = 'A' + miniestado - 10;
  csca.print(caracterH);
  csca.print(caracterL);
  
}
void loop() {
  char comando, numero;
  // put your main code here, to run repeatedly:
  while (!csca.available());
  comando = csca.read();
  if (comando == 's' || comando == 'S')
    enviaestado();
  else if (comando == 'a' || comando == 'A') {
    while (!csca.available());
    numero = csca.read();
    if (numero == 'a' || numero == 'A')
      apagatodo();
    else if (numero >= '0' && numero <= '9')
      digitalWrite(3 + numero - '0', LOW);
  }
  else if (comando == 'e' || comando == 'E') {
    while (!csca.available());
    numero = csca.read();
    if (numero >= '0' && numero <= '9')
      digitalWrite(3 + numero - '0', HIGH);
  }
}

Segundo Arduino (Conectado a USB):

Código:
/*
   Comandos:
    s: estado ->devuelve un byte con el estado de cada led
    e:  encender  -> enciende el bit correspondiente al número
    a:  apagar  ->apaga el bit correspondiente...
   en la próxima version haré un
    aa: apagar todos
*/

/*
 * Serial.flush() y csca.flush() no han funcionado
 * Aunque no falla, no he conseguido borrar el buffer de entrada
 * antes de iniciar las comunicaciones
 */

#include<SoftwareSerial.h>
SoftwareSerial csca(11, 2); // RX, TX csca; Comunicacion Serie Con Arduino
byte i;//la pongo global para que le asigne un espacio de memoria ya que la utilizo mucho
void setup() {
  // put your setup code here, to run once:
  Serial.begin(115200);
  csca.begin(57600);
  while (!Serial);
  while (!csca);
  leeestado();
}
void leeestado() {
  char comando;
  byte numero;
  csca.print("S");
  //se solicita el estado y se espera la respuesta
  comando = 0;
  while (comando != 's' && comando != 'S') {//espero a una comunicación que comience por "s"
    while (!csca.available());
    comando = csca.read();
  }
  Serial.print(comando);//solo llega aquí si comando es s o S.El siguiente es el estado en modo byte
  while (!csca.available());
  comando = csca.read();
  Serial.print (comando);
  while (!csca.available());
  comando = csca.read();
  Serial.println (comando);
}
void loop() {
  char comando, numero;
  // put your main code here, to run repeatedly:
  while (!Serial.available());
  comando = Serial.read();
  if (comando == 's' || comando == 'S')
    leeestado();
  else if (comando == 'a' || comando == 'A') {
    while (!Serial.available());
    numero = Serial.read();
    if (numero == 'a' || numero == 'A' || (numero >= '0' && numero <= '9')) {
      csca.print(comando);
      csca.println(numero);
      leeestado();
    }
  }
  else if (comando == 'e' || comando == 'E') {
    while (!Serial.available());
    numero = Serial.read();
    if (numero >= '0' && numero <= '9') {
      csca.print(comando);
      csca.println(numero);
      leeestado();
    }
  }
}

Control de 8 salidas mediante comunicación serie. Parte 1-directamente-

El objetivo va a ser comunicar dos Arduinos para que se conecten entre ellos mediante comunicación serie. De momento la comunicación directa USB va perfecta y tengo problemas en la comunicación entre los dos Arduinos.
Como voy a utilizar indistintamente unos y leonardos voy a utilizar para la RX la E/S 11 Y para la TX la E/S 2.
Para las salidas utilizaré las E/S desde la 3 hasta la 10.

Diseño en tinkercad que funciona utilizando la conexión serie: https://www.tinkercad.com/things/goZkgRKK088

Código:

/*
   Comandos:
    s: estado ->devuelve un byte con el estado de cada led
    e:  encender  -> enciende el bit correspondiente al número
    a:  apagar  ->apaga el bit correspondiente...
   en la próxima version haré un
    aa: apagar todos
*/
void setup() {
  // put your setup code here, to run once:
  Serial.begin(115200);
  while (!Serial);
  for (byte i = 0; i < 8; i++)
    pinMode(i + 3, OUTPUT);
  apagatodo();//lo voy a hacer ya para apagar todo al comienzo
}
void apagatodo() {
  byte i;
  for (i = 0; i < 8; i++)
    digitalWrite(i + 3, LOW);
}
void enviaestado() {
  byte estado, i;
  for (i = 0; i < 8; i++)
    bitWrite(estado, i, digitalRead(i + 3));
  Serial.print("S");
  Serial.println(estado, HEX);
  Serial.flush();
}
void loop() {
  char comando, numero;
  // put your main code here, to run repeatedly:
  while (!Serial.available());
  comando = Serial.read();
  if (comando == 's' || comando == 'S')
    enviaestado();
  else if (comando == 'a' || comando == 'A') {
    while (!Serial.available());
    numero = Serial.read();
    if (numero == 'a' || numero == 'A')
      apagatodo();
    else if (numero >= '0' && numero <= '9')
      digitalWrite(3 + numero - '0', LOW);
    enviaestado();
  }
  else if (comando == 'e' || comando == 'E') {
    while (!Serial.available());
    numero = Serial.read();
    if (numero >= '0' && numero <= '9')
      digitalWrite(3 + numero - '0', HIGH);
    enviaestado();
  }
}

Imprimir por el puerto serie lo que se a introducido en el mismo orden e invertido.

Imprimir por el puerto serie lo que se a introducido en el mismo orden e invertido:

void setup() {
  Serial.begin(9600);
}
void loop() {
  byte i=0;
  char texto[100];
  while (Serial.available()){
    texto[i++]=Serial.read();
  }
  if (i) {
    for (int j=0;j<i;j++) Serial.print(texto[j]);
    for (int j=1;j<i;j++) Serial.print(texto[i-j-1]);
    Serial.println();
  }
}

Codificador rotatorio (KY-040 Rotary Encoder Module)

Modelo básico. No utilizo la entrada sw (podría hacer un reset con ella.
Visualizo los 4 pasos y cada vez que finaliza incremento o decremento una unidad el contador. Se puede generar variantes que vayan 2 veces más rápido e incluso 4 veces.

Esquema:
Los leds se llevan a positivo para que en la posición de reposo los LEDs estén apagados.

Esquema realizado con Fritzing. Se necesita la librería del codificador:
https://github.com/hduijn/arduino-dehydrator/blob/master/Fritzing/parts/Rotary%20Encoder%20with%20switch%20(KY-040).fzpz
Fichero de Frtitzing y librería descargada:
https://drive.google.com/open?id=1EdaMBKV06V_dZRHLaRhoIQ14QFzxyQoT
https://drive.google.com/open?id=1G0PAIbRtaSDoQXofP98tQz2rsd6w8KS1

 El diagrama del programa es similar al de los circuitos digitales secuenciales asíncronos.

Código del programa:

************************************************************************************
#define clk 2
#define dt 3
int contador=0;
/* PINES
 *
 * CLK
 * DT
 * SW
 * +
 * GND
 */

/* FUNCIONAMIENTO
 * 
 *  PARTIENDO DE REPOSOSO (CLK, DT): 1,1
 * 
 *  GIRO EN SENTIDO HORARIO (derecha):
 *  1,1
 *  0,1
 *  0,0
 *  1,0
 *  0,0
 * 
 *  GIRO EN SENTIDO ANTIHORARIO (izquierda):
 *  1,1
 *  0,1
 *  0,0
 *  1,0
 *  1,1
 */

//voy a comenzar patiendo de reposo (1,1)
//main (loop) se va a quedar hasta que se produzca la situación (1,1)
//entonces pasará a la función pseudoloop

void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
  pinMode(clk, INPUT);
  pinMode(dt, INPUT);
}

void loop() {
  // put your main code here, to run repeatedly:
  if(digitalRead(clk) && digitalRead(dt)) contar11(0);
}

void contar11(int precontador){
  if (precontador==4){
    Serial.println(++contador);
    precontador=0;
  } else if (precontador==-4){
    Serial.println(--contador);
    precontador=0;
  }
  //no necesito hacer más pruebas porque la otra posibilidad es que se haya movido hacia atrás y valdrá cero
 
  while (digitalRead(clk) && digitalRead(dt));//mientras las dos sigan a 1 no se hace nada
  if(!digitalRead(clk)){
    contar01(++precontador);
  } else {
    contar10(--precontador);
  }
}

void contar01(int precontador){
  while (!digitalRead(clk) && digitalRead(dt));
  if(!digitalRead(dt)){
    contar00(++precontador);
  } else {
    contar11(--precontador);
  }
}

void contar00(int precontador){
  while (!digitalRead(clk) && !digitalRead(dt));
  if(digitalRead(clk)){
    contar10(++precontador);
  } else {
    contar01(--precontador);
  }
}

void contar10(int precontador){
  while (digitalRead(clk) && !digitalRead(dt));
  if(digitalRead(dt)){
    contar11(++precontador);
  } else {
    contar00(--precontador);
  }
}
************************************************************************************

Devuelve el ROT13. Comunicación mediante puerto serie.

void setup(){
  Serial.begin(9600);//inicializar puerto serie a 9600
}

void loop(){
  byte i;
  i=0;// lo pongo así porque no estoy seguro de que se vaya a reiniciar en cada loop
  char texto[100];// la variable en la que voy a almacenar la cadena de texto
  while (Serial.available()){//Serial.available devuelve el numero de caracteres que tiene en el buffer. Si no hay nada estará a cero y no se cumplirá la condición
    texto[i++]=Serial.read();//si entra, puesto que i en el inicio vale cero irá almacenando los caracteres del buffer en el array de caracteres, que se auto-post-incrementa (i++)
  }
  byte j;//utilizo una segunda variable para ir recorriendo el array de caracteres
  if (i) rota(texto, i);
  for (j=0;j<i;j++) Serial.print(texto[j]);//imprimo todos los caracteres(el último no se imprime porque es [NULL]=0x00
  if (i) Serial.println("");//Si ha habido impresión i será distinto a 0 e imprimo un salto de línea
}

void rota (char* cadena, byte tamano){
  for (byte i=0;i<tamano;i++){
    if (cadena[i]>='A' && cadena[i]<='Z') cadena[i]=r13(cadena[i], 'A', 'Z');
    else if (cadena[i]>='a' && cadena[i]<='z') cadena[i]=r13(cadena[i], 'a', 'z');
  }
}

char r13(unsigned char car, char menor, char mayor){//hago car de tipo unsigned porque puede superar el 0xEF y lo considera negativo
  car+=13;
  if (car>mayor) car=menor+(car-mayor)-1;
  return car;
}

Comunicaciones a través del puerto serie. En este caso con la terminal.

Tiene comentarios.

void setup(){
  Serial.begin(9600);//inicializar puerto serie a 9600
}

void loop(){
  byte i;
  i=0;// lo pongo así porque no estoy seguro de que se vaya a reiniciar en cada loop
  char texto[100];// la variable en la que voy a almacenar la cadena de texto
  while (Serial.available()){//Serial.available devuelve el numero de caracteres que tiene en el buffer. Si no hay nada estará a cero y no se cumplirá la condición
    texto[i++]=Serial.read();//si entra, puesto que i en el inicio vale cero irá almacenando los caracteres del buffer en el array de caracteres, que se autoincrementa (i++)
  }
  byte j;//utilizo una segunda variable para ir recorriendo el array de caracteres
  for (j=0;j<i;j++) Serial.print(texto[j]);//imprimo todos los caracteres(el último no se imprime porque es [NULL]=0x00
  if (i) Serial.println("");//Si ha habido impresión i será distinto a 0 e imprimo un salto de línea
}

Servidor http con ESP32 (8 bits)

Falta depurar el código, limpiar comentarios y activar las correspondientes salidas, pero ya funciona.
No olvidar poner el nombre de la red y el password.

Código:


#include <WiFi.h>

// Replace with your network credentials
const char* ssid = "ssid";
const char* password = "password";//he habilitado el acceso a la red de área local
//ya funciona con inbita2

WiFiServer server(80);

const int led = 2; // the number of the LED pin

// Client variables
char linebuf[80];
int charcount = 0;

int estado=0;//byte con información de las 8 salidas

void setup()
{
  estado=0;
  // initialize the LED as an output:
  //pinMode(led, OUTPUT);
  //Initialize serial and wait for port to open:
  Serial.begin(115200);
  while (!Serial) {
  }

  // We start by connecting to a WiFi network
  Serial.println();
  Serial.println();
  Serial.print("Connecting to ");
  Serial.println(ssid);

  WiFi.begin(ssid, password);

  // attempt to connect to Wifi network:
  while (WiFi.status() != WL_CONNECTED)
  {
    // Connect to WPA/WPA2 network.
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.println("WiFi connected");
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());
  server.begin();
  Serial.print("Estado: ");
  Serial.println(WiFi.status());
}

void loop()
{
  delay(1000);
  // listen for incoming clients
  WiFiClient client = server.available();
  if (client)
  {
    Serial.println("New client");
    memset(linebuf, 0, sizeof(linebuf));
    charcount = 0;
    // an http request ends with a blank line
    boolean currentLineIsBlank = true;
    while (client.connected())
    {
      if (client.available())
      {
        char c = client.read();
        Serial.write(c);
        //read char by char HTTP request
        linebuf[charcount] = c;
        if (charcount < sizeof(linebuf) - 1) charcount++;

        if (c == '\n' && currentLineIsBlank)
        {
          // send a standard http response header
          client.println("HTTP/1.1 200 OK");
          client.println("Content-Type: text/html");
          client.println("Connection: close"); // the connection will be closed after completion of the response
          client.println();
          client.println("<!DOCTYPE HTML><html><head>");
          client.println("<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\"></head>");
          client.println("<h1>ESP32 - Web Server example</h1>");
          client.println("<p>LED <a href=\"01\"><button>ON</button></a>&nbsp;<a href=\"00\"><button>OFF</button></a></p>");
          client.println("<p>LED <a href=\"11\"><button>ON</button></a>&nbsp;<a href=\"10\"><button>OFF</button></a></p>");
          client.println("<p>LED <a href=\"21\"><button>ON</button></a>&nbsp;<a href=\"20\"><button>OFF</button></a></p>");
          client.println("<p>LED <a href=\"31\"><button>ON</button></a>&nbsp;<a href=\"30\"><button>OFF</button></a></p>");
          client.println("<p>LED <a href=\"41\"><button>ON</button></a>&nbsp;<a href=\"40\"><button>OFF</button></a></p>");
          client.println("<p>LED <a href=\"51\"><button>ON</button></a>&nbsp;<a href=\"50\"><button>OFF</button></a></p>");
          client.println("<p>LED <a href=\"61\"><button>ON</button></a>&nbsp;<a href=\"60\"><button>OFF</button></a></p>");
          client.println("<p>LED <a href=\"71\"><button>ON</button></a>&nbsp;<a href=\"70\"><button>OFF</button></a></p>");
          client.println("<table>");
          client.println("<tr>");
          client.println("<td  align=\"center\">0</td>");
          client.println("<td  align=\"center\">1</td>");
          client.println("<td  align=\"center\">2</td>");
          client.println("<td  align=\"center\">3</td>");
          client.println("<td  align=\"center\">4</td>");
          client.println("<td  align=\"center\">5</td>");
          client.println("<td  align=\"center\">6</td>");
          client.println("<td  align=\"center\">7</td>");
          client.println("</tr>");
          client.println("<tr>");
          client.print("<td  align=\"center\">");
          if (estado & 0x80) {
            client.print("<div style=\"width: 100px; height: 100px; background: #00ff00;\"></div>");
          }
          else {
            client.print("<div style=\"width: 100px; height: 100px; background: #ff0000;\"></div>");
          }
          client.print("</td>");
          client.print("<td  align=\"center\">");
          if (estado & 0x40) {
            client.print("<div style=\"width: 100px; height: 100px; background: #00ff00;\"></div>");
          }
          else {
            client.print("<div style=\"width: 100px; height: 100px; background: #ff0000;\"></div>");
          }
          client.print("</td>");
          client.print("<td  align=\"center\">");
          if (estado & 0x20) {
            client.print("<div style=\"width: 100px; height: 100px; background: #00ff00;\"></div>");
          }
          else {
            client.print("<div style=\"width: 100px; height: 100px; background: #ff0000;\"></div>");
          }
          client.print("</td>");
          client.print("<td  align=\"center\">");
          if (estado & 0x10) {
            client.print("<div style=\"width: 100px; height: 100px; background: #00ff00;\"></div>");
          }
          else {
            client.print("<div style=\"width: 100px; height: 100px; background: #ff0000;\"></div>");
          }
          client.print("</td>");
          client.print("<td  align=\"center\">");
          if (estado & 0x08) {
            client.print("<div style=\"width: 100px; height: 100px; background: #00ff00;\"></div>");
          }
          else {
            client.print("<div style=\"width: 100px; height: 100px; background: #ff0000;\"></div>");
          }
          client.print("</td>");
          client.print("<td  align=\"center\">");
          if (estado & 0x04) {
            client.print("<div style=\"width: 100px; height: 100px; background: #00ff00;\"></div>");
          }
          else {
            client.print("<div style=\"width: 100px; height: 100px; background: #ff0000;\"></div>");
          }
          client.print("</td>");
          client.print("<td  align=\"center\">");
          if (estado & 0x02) {
            client.print("<div style=\"width: 100px; height: 100px; background: #00ff00;\"></div>");
          }
          else {
            client.print("<div style=\"width: 100px; height: 100px; background: #ff0000;\"></div>");
          }
          client.print("</td>");
          client.print("<td  align=\"center\">");
          if (estado & 0x01) {
            client.print("<div style=\"width: 100px; height: 100px; background: #00ff00;\"></div>");
          }
          else {
            client.print("<div style=\"width: 100px; height: 100px; background: #ff0000;\"></div>");
          }
          client.print("</td>");


         
          client.print("</tr>");
          client.print("</table>");
         

         
          client.println("</html>");
          break;
        }
        if (c == '\n')
        {
          // you're starting a new line
          currentLineIsBlank = true;
          if (strstr(linebuf, "GET /00") > 0)
          {
            //Serial.println("LED ON");
            Serial.println("LED 0 ON");
            estado &= 0x7F; //AND CON 0111 1111
            //digitalWrite(led, HIGH);
          }
          else if (strstr(linebuf, "GET /01") > 0)
          {
            //Serial.println("LED OFF");
            Serial.println("LED 0 OFF");
            estado |= 0x80; //OR CON 1000 0000
            //digitalWrite(led, LOW);
          }


          if (strstr(linebuf, "GET /10") > 0)
          {
            //Serial.println("LED ON");
            Serial.println("LED 1 ON");
            estado &= 0xBF; //AND CON 1011 1111
            //digitalWrite(led, HIGH);
          }
          else if (strstr(linebuf, "GET /11") > 0)
          {
            //Serial.println("LED OFF");
            Serial.println("LED 1 OFF");
            estado |= 0x40; //OR CON 0100 0000
            //digitalWrite(led, LOW);
          }


          if (strstr(linebuf, "GET /20") > 0)
          {
            //Serial.println("LED ON");
            Serial.println("LED 2 ON");
            estado &= 0xDF; //AND CON 1101 1111
            //digitalWrite(led, HIGH);
          }
          else if (strstr(linebuf, "GET /21") > 0)
          {
            //Serial.println("LED OFF");
            Serial.println("LED 2 OFF");
            estado |= 0x20; //OR CON 0010 0000
            //digitalWrite(led, LOW);
          }


          if (strstr(linebuf, "GET /30") > 0)
          {
            //Serial.println("LED ON");
            Serial.println("LED 3 ON");
            estado &= 0xEF; //AND CON 1110 1111
            //digitalWrite(led, HIGH);
          }
          else if (strstr(linebuf, "GET /31") > 0)
          {
            //Serial.println("LED OFF");
            Serial.println("LED 3 OFF");
            estado |= 0x10; //OR CON 0001 0000
            //digitalWrite(led, LOW);
          }


          if (strstr(linebuf, "GET /40") > 0)
          {
            //Serial.println("LED ON");
            Serial.println("LED 4 ON");
            estado &= 0xF7; //AND CON 1111 0111
            //digitalWrite(led, HIGH);
          }
          else if (strstr(linebuf, "GET /41") > 0)
          {
            //Serial.println("LED OFF");
            Serial.println("LED 4 OFF");
            estado |= 0x08; //OR CON 0000 1000
            //digitalWrite(led, LOW);
          }


          if (strstr(linebuf, "GET /50") > 0)
          {
            //Serial.println("LED ON");
            Serial.println("LED 5 ON");
            estado &= 0xFB; //AND CON 1111 1011
            //digitalWrite(led, HIGH);
          }
          else if (strstr(linebuf, "GET /51") > 0)
          {
            //Serial.println("LED OFF");
            Serial.println("LED 5 OFF");
            estado |= 0x04; //OR CON 0000 0100
            //digitalWrite(led, LOW);
          }


          if (strstr(linebuf, "GET /60") > 0)
          {
            //Serial.println("LED ON");
            Serial.println("LED 6 ON");
            estado &= 0xFD; //AND CON 1111 1101
            //digitalWrite(led, HIGH);
          }
          else if (strstr(linebuf, "GET /61") > 0)
          {
            //Serial.println("LED OFF");
            Serial.println("LED 6 OFF");
            estado |= 0x02; //OR CON 0000 0010;
            //digitalWrite(led, LOW);
          }


          if (strstr(linebuf, "GET /70") > 0)
          {
            //Serial.println("LED ON");
            Serial.println("LED 7 ON");
            estado &= 0xFE; //AND CON 1111 1110;
            //digitalWrite(led, HIGH);
          }
          else if (strstr(linebuf, "GET /71") > 0)
          {
            //Serial.println("LED OFF");
            Serial.println("LED 7 OFF");
            estado |= 0x01; //OR CON 0000 0001
            //digitalWrite(led, LOW);
          }



          // you're starting a new line
          currentLineIsBlank = true;
          memset(linebuf, 0, sizeof(linebuf));
          charcount = 0;
        }
        else if (c != '\r')
        {
          // you've gotten a character on the current line
          currentLineIsBlank = false;
        }
      }
    }



          Serial.print("Estado de las salidas: ");
          Serial.println(estado, HEX);
    // give the web browser time to receive the data
    delay(1);

    // close the connection:
    client.stop();
    Serial.println("client disconnected");
  }
}

Medir distancia mediante ESP32 y enviar al puerto serie

int EchoPin = 13;
int TriggerPin = 12;

void setup() {
   Serial.begin(115200);
   pinMode(TriggerPin, OUTPUT);
   pinMode(EchoPin, INPUT);
}

void loop() {
   int cm = ping(TriggerPin, EchoPin);
   Serial.print("Distancia: ");
   Serial.println(cm);
   delay(1000);
}

int ping(int TriggerPin, int EchoPin) {
   long duration, distanceCm;
  
   digitalWrite(TriggerPin, LOW);  //para generar un pulso limpio ponemos a LOW 4us
   delayMicroseconds(4);
   digitalWrite(TriggerPin, HIGH);  //generamos Trigger (disparo) de 10us
   delayMicroseconds(10);
   digitalWrite(TriggerPin, LOW);
  
   duration = pulseIn(EchoPin, HIGH);  //medimos el tiempo entre pulsos, en microsegundos
  
   distanceCm = duration * 10 / 292/ 2;   //convertimos a distancia, en cm
   return distanceCm;
}

ESP32 con matriz 16x16 dos imagenes que cambian usando millis() con un retardo de 1000 ms

//salidas que se van a utilizar
#define dataPin 13
#define clockPin 12
#define latchPin 14

uint16_t dato1[] = {
  0xFFFF,
  0x8001,
  0xBFFD,
  0xA005,
  0xAFF5,
  0xA815,
  0xABD5,
  0xAA55,
  0xAA55,
  0xABD5,
  0xA815,
  0xAFF5,
  0xA005,
  0xBFFD,
  0x8001,
  0xFFFF
};

uint16_t dato2[] = {
  0x0000,
  0x7FFE,
  0x4002,
  0x5FFA,
  0x500A,
  0x57EA,
  0x542A,
  0x55AA,
  0x55AA,
  0x542A,
  0x57EA,
  0x500A,
  0x5FFA,
  0x4002,
  0x7FFE,
  0x0000
};

byte i, j;
byte fi_L, fi_H;

void setup() {
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
  for (i = 0; i < 16; i++) dato1[i] ^= 0xFFFF;
  for (i = 0; i < 16; i++) dato2[i] ^= 0xFFFF;
}

void loop() {
  muestra (dato1);
  //delay(1000);
  muestra (dato2);
  //delay(1000);
}

void muestra (uint16_t *matriz) {
  double t_inicio;
  unsigned int retardo=1000;
  uint16_t aux;
  byte enviar;
  uint16_t n_fila;
  int n;
  t_inicio = millis();
  while (millis()<(t_inicio+retardo)) {
    n_fila = 1;
    for (i = 0; i < 16; i++, n_fila <<= 1) {
      fi_L = n_fila & 0xFF;
      fi_H = (n_fila >> 8) & 0xFF;
      digitalWrite(latchPin, 0);
      shiftOut(dataPin, clockPin, LSBFIRST, fi_L);
      shiftOut(dataPin, clockPin, LSBFIRST, fi_H);
      aux = matriz[i];
      enviar = aux & 0x00ff;
      shiftOut(dataPin, clockPin, LSBFIRST, enviar);
      enviar = (aux >> 8) & 0x00ff;
      shiftOut(dataPin, clockPin, LSBFIRST, enviar);
      digitalWrite(latchPin, 1);
    }
  }
}

ESP32 con la matriz de 16x16. Mensaje HOLA.

//salidas que se van a utilizar
//pongo las 5 seguidas para que sea más sencillo conectarlas
//VCC
//GND
#define dataPin 13
#define clockPin 12
#define latchPin 14

/*
 * poniendo el array en uint16_t y colocando la información en columnas en vez de en filas sería más facil crear mensajes largos
 */
//array en el que se va a contener toda la informacin de filas
uint32_t dato[] = {
  0xCC7183F0,
  0xCCF983F0,
  0xCDDD8330,
  0xCD8D8330,
  0xCD8D8330,
  0xCD8D8330,
  0xCD8D8330,
  0xFD8D83F0,
  0xFD8D83F0,
  0xCD8D8330,
  0xCD8D8330,
  0xCD8D8330,
  0xCD8D8330,
  0xCDDD8330,
  0xCCF9FB36,
  0xCC71FB36
};//informacion de las columnas

byte i, j;
byte fi_L, fi_H;

void setup() {
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
  for (i = 0; i < 16; i++) dato[i] ^= 0xFFFFFFFF; //invierto todos los bits porque las columnas van a los cátodos.
  //si se cambia por uint16_t habría que cambiar esto de la inversión
}

void loop() {
  muestra (dato,32,1000);//(matriz, ancho de la matriz, numero de repeticiones) cuanto mayor sea el numero de repeticiones más tardará en pasar a la siguiente columna.
  uint32_t limpia[16];
  for (int i=0;i<16;i++){
    limpia[i]=0xFFFFFFFF;
  }
  muestra(limpia,32,10);
  delay(1000);
}

void muestra (uint32_t *matriz, int ancho, unsigned int numero_rep) {//puesto que es una variable global podría usar dato[]
  double t_inicio;
  uint32_t aux;
  byte enviar;
  uint16_t n_fila;
  //unsigned int n;
  for (j = 0; j < ancho - 16; j++) {//empiezo en 32 porque es la anchura total (para empezar por el extremo izquierdo termino en 32-16 porque la anchura de la matriz de puntos es 16
    for (int n = 0; n < numero_rep; n++) {//es una espera (va a repetir la información hasta saltar a la siguiente columna. Por eso no se hace nada con n.

      //se posiciona la variable que indica el numero de fila en la primera fila (como es de 16 bits, se carga en una variable uint16_n)
      n_fila = 1;

      //como tiene 16 filas se van a enviar de una en una
      for (i = 0; i < 16; i++, n_fila <<= 1) {//lo de rotar 1 bit a la izquierda es para que pase a la siguiente columna

        //se extraen los bytes de menor y menor peso

        //el de menor peso mediante una AND con 0000 0000 1111 1111
        fi_L = n_fila & 0xFF;

        //el de mayor peso mediante la misma AND pero con la variable n_fila desplazada 1 byte hacia la derecha
        fi_H = (n_fila >> 8) & 0xFF;

        //se prepara para recibir datos
        digitalWrite(latchPin, 0);

        //se envía la información de la fila (lógica positiva, una fila de cada vez)
        shiftOut(dataPin, clockPin, LSBFIRST, fi_L);
        shiftOut(dataPin, clockPin, LSBFIRST, fi_H);

        //se envía la información de la columna (lógica negativa, por eso se invierte la matriz en setup()

        //se posiciona en el primer bit desplazando el ancho total - 16 - i (que va a variar) y se carga en una variable de tipo uint32_n (como la matriz)
        aux = matriz[i] >> (ancho - 16 - j);
        //se cogen el byte de menor peso (operación AND con 0000 0000 1111 1111)
        enviar = aux & 0x00ff;
        //se envía el byte de menor peso que se había extraido
        shiftOut(dataPin, clockPin, LSBFIRST, enviar);
        //se extrae el segundo byte porque el dato se va a desplazar 1 byte a la derecha (el resto es como el anterior)
        enviar = (aux >> 8) & 0x00ff;
        shiftOut(dataPin, clockPin, LSBFIRST, enviar);

        //se desactiva la recepción de datos y por lo tanto los va a mostrar
        digitalWrite(latchPin, 1);
      }
    }//cuando ha repetido el numero de veces seleccionado, se pasa a la siguiente columna.
  }
}

How to use 315Mhz RF transmitter and receiver modules with arduino

http://www.buildcircuit.com/how-to-use-rf-module-with-arduino/

Hay que descargar la librería que utilizan en el ejemplo: http://www.pjrc.com/teensy/td_libs_VirtualWire.html

Pongo los códigos fuente:

emisor: https://gist.githubusercontent.com/buildcircuit/5907275/raw/gistfile1.ino

/*
SimpleSend
This sketch transmits a short text message using the VirtualWire library
connect the Transmitter data pin to Arduino pin 12
*/
#include <VirtualWire.h>
void setup()
{
// Initialize the IO and ISR
vw_setup(2000); // Bits per sec
}
void loop()
{
send("Hello there");
delay(1000);
}
void send (char *message)
{
vw_send((uint8_t *)message, strlen(message));
vw_wait_tx(); // Wait until the whole message is gone
}

receptor: https://gist.githubusercontent.com/buildcircuit/5907280/raw/gistfile1.ino

/*
SimpleReceive
This sketch displays text strings received using VirtualWire
Connect the Receiver data pin to Arduino pin 11
*/
#include <VirtualWire.h>
byte message[VW_MAX_MESSAGE_LEN]; // a buffer to store the incoming messages
byte messageLength = VW_MAX_MESSAGE_LEN; // the size of the message
void setup()
{
Serial.begin(9600);
Serial.println("Device is ready");
// Initialize the IO and ISR
vw_setup(2000); // Bits per sec
vw_rx_start(); // Start the receiver
}
void loop()
{
if (vw_get_message(message, &messageLength)) // Non-blocking
{
Serial.print("Received: ");
for (int i = 0; i < messageLength; i++)
{
Serial.write(message[i]);
}
Serial.println();
}
}

SD Card Socket Modlue +2.8" Inch TFT Touch Screen Development Board For Arduino

De momento pongo la copia de seguridad del CD que le acompañaba. parece que es elentorno de programación de arduino adaptado para este dispositivo y que solo funciona en windows. Al menos el ejecutable es para windows, deduzco que las librerías que le acompañan son para el mismo sistema operativo y que por lo tanto desde otros sistemas operativos no va a funcionar.

El enlace al fichero es: https://drive.google.com/file/d/0B779vDAuKIBKSWJsMEY0OE0yZ3M/edit?usp=sharing

2088RGB-5 (Matriz RGB de 8x8 de ánodo común sin resistencias)

Hoja básica de características:

Imagen de las conexiones del dispositivo:

Se puede ver que la patilla nº 1 es la de la esquina inferior derecha.
Alguien (https://www.flickr.com/photos/madworm_de/2997547008/sizes/o/in/photostream/) ha puesto esto en internet:

Aunque no son idénticos, es facil comprobar si está bien o mal. Mediante un polímetro se localiza el ánodo y el resto solo es saber de que color es cada grupo.
Lo importante viene ahora. Hay varias soluciones para enviar los datos.

• Enviar los 32 datos vía serie.
• Enviar 4 grupos de datos vía serie (uno para cada color y otro para en ánodo).
• Enviar 4 grupos de 8 bits.

El más lógico parece el último porque sería más rápido, solo serían necesarios 4 buffers (no sería necesario poner registros de desplazamiento). A cambio, se necesitan más salidas: 8 bits para los datos y 4 para las direcciones (que podrían quedarse en 2 si se multiplexan). Lo de multiplexar salidas sería recomendable en caso de que no disponer de suficientes salidas. A cambio, no se podría enviar el mismo dato a todas a la vez (por ejemplo encender o apagar todo a la vez).

En todos los casos se hace necesario fabricar un circuito impreso y eso lleva a una nueva duda. Poner resistencias en los cátodos o en el ánodo.
Ventajas e inconvenientes de cada una de las soluciones (no voy a tener en cuenta la económica porque es una miseria):

• Más resistencias => Circuito impreso más grande
• Más resistencias => Mayor facilidad para conectar los dispositivos al poder pasar las pistas por debajo de las resistencias.
• Más resistencias => Más luz que si tienen una común.
• Más resistencias => Más control de la corriente de cada led (tienen distintas corrientes/tensiones de funcionamiento).
• Resistencia común => Es posible que los colores azul y verde no se enciendan si se activan con el rojo porque funciona con menos tensión (no lo he comprobado)

Después de valorar todo, creo que es mejor utilizar 12 salidas del arduino (no multiplexar) y poner 24 resistencias.
Falta localizar los circuitos integrados con 8 básculas tipo D adecuados y calcular las resistencias.
De momento ya he expuesto las ideas. Cuando vuelva a hacer algo lo publicaré.
He encontrado algo que podría valer: 74XX373

• Tiene un precio razonable.
• A pesar de ser de la serie 74 es un CMOS.
• Tiene un consumo reducido.
• Tiene un buen margen de tensiones de alimentación.
• Puede suministrar perfectamente la corriente que precisan los LEDs.
• Cumple sobradamente con las carácterísticas (le sobra la salida triestado pero es facil inhabilitarla poniendo Output Enable a cero)
• El patillaje es un poco complejo para el circuito impreso porque se llenaría de cruces por la configuración de entradas/salidas.

Hay un datasheet en: http://www.harrisonelectronics.co.uk/datasheets/MC74HC373ADW.pdf
Y en su página principal hay datasheets de muchos componentes corrientes (muy utilizados): Harrison Electronics

Creo que ya está: http://www.fairchildsemi.com/ds/74/74VHC573.pdf
http://pinout-circuits-images.dz863.com/6/CD74HC573.jpg

Se puede ver que a un lado están  las entradas y a otro las salidas. Lo mismo que en el 373 hay que poner la patilla 1 a masa para que esté siempre activado (no se necesita el triestado).

Para el cálculo de las resistencias he encontrado un problema: potencia máxima 150 mw. Teniendo en cuenta que:

• LED Rojo: 2,2V/50mA=110mw
• LED Verde: 3,3V/50mA=165mw
• LED Azul: 3,3V/50mA=165mw

No se si 150mw se refiere a la potencia máxima que soporta cada conjunto o cada led individual.
En el caso de que sea el primero (lo más probable por la refrigeración) habría que poner una resistencia común o evitar encender los tres a la vez.
Si se hace pasar 15 mA por LED, no se superaría la potencia máxima aunque se activaran los 3 simultáneamente.
Los valores serían:

• R: (5V-2,2V)/15mA=187 Ohm
• G: (5V-3,3V)/15mA=113 Ohm
• B: (5V-3,3V)/15mA=113 Ohm
• Valores normalizados (E24 - 5%):
• R: 150-200=> 200 Ohm
• G=B: 110-130 => 110 Ohm
• Valores normalizados (E12 - 10%):
• R: 150-270 => 150 Ohm -> I=2,8V/150=18,7mA
• G-B: 100-150 => 100 Ohm -> I=1,7/100=17mA
• Potencias para E12:
• R: 2,8V*18,7mA=52,36mw
• G-B:1,7V*17mA=28.9mw
• Potencia TOTAL=52,36+28,9+28,9=110,16mw

Incluso poniendo resistencias muy distintas a las inicialmente calculadas estaría lejos de la potencia máxima.
Falta diseñar la placa de circuito impreso, a ser posible de una cara. Eso llevará más tiempo...

Juego de luces sencillo para matriz 16x16

Se va acercando desde las 4 esquinas hacia el centro y cuando llega se enciende entero:

Código fuente:

//salidas que se van a utilizar
int latchPin = 8; //patilla LT
int clockPin = 12; //patilla SK
int dataPin = 11; //patilla RI1
//array en el que se va a contener toda la informacin de filas y columnas
byte dato[4];
byte i;

void setup() {
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
  dato[0]=0xFF;
  dato[1]=0xFF;
  dato[2]=0x00;
  dato[3]=0x00;
  envia_datos(dato);
}

void envia_datos(byte *matrix) {
  digitalWrite(latchPin, 0);
  for (byte i=4; i>2; i--) shiftOut(dataPin, clockPin, LSBFIRST, matrix[i-1]);
  for (byte i=2; i>0; i--) shiftOut(dataPin, clockPin, MSBFIRST, matrix[i-1]);
  digitalWrite(latchPin, 1);
  delay(500);
}

void loop() {
  dato[3]=0x01;
  dato[2]=0x80;
  dato[1]=0x7F;
  dato[0]=0xFE;
  envia_datos(dato);
  delay(500);
 
  for (i=0;i<6;i++){
    dato[3]*=2;  
    bitClear(dato[3],7);
    dato[2]/=2;
    bitClear(dato[2],0);
    dato[1]>>=1;
    bitSet(dato[1], 7);
    dato[0]<<=1;
    bitSet(dato[0], 0);
  envia_datos(dato);
  delay(500);  
  }
  dato[0]=0x00;
  dato[1]=0x00;
  dato[2]=0xFF;
  dato[3]=0xFF;
  envia_datos(dato);
 
  delay(500);
 
  dato[0]=0xFF;
  dato[1]=0xFF;
  dato[2]=0x00;
  dato[3]=0x00;
  envia_datos(dato);
 
  delay(500);

}

Display de 7 segmentos con 8 digitos (MAX7219)_2-Contador pasando de binario a decimal

 Código fuente:

********************************************************
const byte datapin = 12;
const byte latchpin = 11;
const byte clockpin = 10;

void setup() {
  pinMode(datapin, OUTPUT);
  pinMode(latchpin, OUTPUT);
  pinMode(clockpin, OUTPUT);
  // set : Normal Mode
  digitalWrite(latchpin, LOW);
  shiftOut(datapin, clockpin, MSBFIRST, 0x0C );
  shiftOut(datapin, clockpin, MSBFIRST, 0x01 );
  digitalWrite(latchpin, HIGH);
  delay(5);
  // set : Normal Operation
  digitalWrite(latchpin, LOW);
  shiftOut(datapin, clockpin, MSBFIRST, 0x0F );
  shiftOut(datapin, clockpin, MSBFIRST, 0x00 );
  digitalWrite(latchpin, HIGH);
  delay(5);
  // set : Intensity
  digitalWrite(latchpin, LOW);
  shiftOut(datapin, clockpin, MSBFIRST, 0x0A );
  shiftOut(datapin, clockpin, MSBFIRST, 0x0B );
  digitalWrite(latchpin, HIGH);
  delay(5);
  // set : Numbers of digits
  digitalWrite(latchpin, LOW);
  shiftOut(datapin, clockpin, MSBFIRST, 0x0B );
  shiftOut(datapin, clockpin, MSBFIRST, 0x07 );
  digitalWrite(latchpin, HIGH);
  delay(5);
  // set : Decode Mode Register
  digitalWrite(latchpin, LOW);
  shiftOut(datapin, clockpin, MSBFIRST, 0x09 );
  shiftOut(datapin, clockpin, MSBFIRST, 0xFF );
  digitalWrite(latchpin, HIGH);
}

void loop() {
  unsigned long numero=99988888;
  int i;
  for (i=1;i<9;i++)
  {
    digitalWrite(latchpin, LOW);
    shiftOut(datapin, clockpin, MSBFIRST, i );
    shiftOut(datapin, clockpin, MSBFIRST, 15 );
    digitalWrite(latchpin, HIGH);
    //delay(5);
  }
  do {
    envDispl(numero);
    numero++;
  } while (numero < 100000000);//unsigned long puede representar hasta: 4.294.967.295 (2^32 - 1) porque tiene 4 bytes (32 bits)
}

void envDispl(unsigned long numero) {
  unsigned long k=10000000;
  int i, j;
  for (i=8; i>0; i--) {
    j=numero/k;
    digitalWrite(latchpin, LOW);
    shiftOut(datapin, clockpin, MSBFIRST, i );
    shiftOut(datapin, clockpin, MSBFIRST, j );
    digitalWrite(latchpin, HIGH);
    numero%=k;
    k=k/10;
    //delay (5);
  }
}