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
}