Motika By CVR | Arduino

Iniciar con Arduino


Arduino diseña, fabrica y admite dispositivos electrónicos y software, lo que permite a las personas de todo el mundo acceder fácilmente a tecnologías avanzadas que interactúan con el mundo físico. Nuestros productos son sencillos, simples y potentes, listos para satisfacer las necesidades de los usuarios, desde estudiantes hasta creadores y hasta desarrolladores profesionales.

Motika puede ser programado con Arduino IDE bajo el lenguaje C++ con instalando paquetes adicionales para la programación del microcontrolador ESP8266.

Mas informacion sobre Arduino aquí

GPIO(I/O) Motika Arduino

Los pines de proposito general disponibles en la placa Motika bajo el uso de Arduino se describen a continucación


imagen io arduino

Instalando las herramientas necesarias:
Toda la documentación disponible para programar el microcontrolador Esp8266 (nucleo motika) está en el siguiente repositorio: https://github.com/esp8266/Arduino



PASO 1:
Inicial mente, debemos dirigirnos a la ruta la ruta: file->preference tal y como se muestra en la siguiente imagen:

imagen paso 1

PASO 2:
En la ventana preferencias, nos situaremos en la parte inferior de la ventana y en la seccion Additional boards manager URLs, agregaremos lo siguiente:

https://arduino.esp8266.com/stable/package_esp8266com_index.json

imagen del menu preferencias imagen del menu preferencias

Una vez agregado, presionamos el botón OK

Con el fin de verificar que el procedimiento se realizó satisfactoriamente vamos a tools->board manager->esp8266 donde se mostrará una nueva lista de placas relacionadas con el miscrocontrolador.

imagen que describe la lista de tarjetas



Ahora estámos listos para iniciar a programar nuestra placa Motika usando Arduino, Solo queda seleccionar como placa la NodeMCU 1.0 ESP12 (Module):

  1. Escribiendo código.
  2. Cargar código a la placa.
  3. Conectar a red wifi.
  4. Crear red wifi.
  5. Controlando cargas.
  6. Crear servidor HTTP para controlar cargas.
  7. Crear socket TCP-IP para controlar cargas
  8. Pines I/O de propósito general.

Escribiendo código
Para escribir código usaremos el IDE Arduino de forma habitual como si os encontraramos programando una placa Arduino. Cabe destacar que tambien puedes usar tu editor de código favorito.

Cargando código a la placa.
La carga de código a la placa es bastante sencilla, esta se realiza usando el botón habitual para cargar código del IDE arduino.
Es indispensable establecer la placa en modo programación haciendo uso del jumper flash tal y como se muestra en la siguiente imagen.

img motika jumper position

Wifi
Motika está basada en el ESP8266, este microcontrolador cuenta con un chip wifi configurable el cual permite conectarse a una red wifi existente (MODO AP) o crear una red wifi desde el propio módulo (MODO STATION) permitiendo así comunicarnos con dispositivos externos mediante protocolos de comunicaciones IP . Toda la informacion sobre wifi en: https://arduino-esp8266.readthedocs.io/en/3.0.2/esp8266wifi/readme.html



Conectar a red wifi.

Conectar con una red wifi es muy fácil, para esto usaremos el siguiente código: 

            
             
#include <Arduino.h>
#include <ESP8266WiFi.h>

String ssid = "el nombre de la red";
String pwd = "la clave de la red";

void setup()
{
  Serial.begin(115200);
  WiFi.begin(ssid, pwd);

  Serial.print("Connecting");
  while (WiFi.status() != WL_CONNECTED)
  {
    delay(500);
    Serial.print(".");
  }
  Serial.println();

  Serial.print("Connected, IP address: ");
  Serial.println(WiFi.localIP());

}


ssid = Nombre de la red wifi a la que se conectará
pwd = Clave de la red



Crear red wifi.
(ver antes conceptos generales de wifi)

                

#include <ESP8266WiFi.h>

const char *ssid = "CVR ELECTRONICA";
const char *password = "cvrelectronica.com";

void setup() {
  Serial.begin(115200);
  delay(10);

  WiFi.mode(WIFI_AP);
  while (!WiFi.softAP(ssid, password)) {
    Serial.println(".");
    delay(100);
  }

  Serial.print("Iniciado AP ");
  Serial.println(ssid);
  Serial.print("IP address:\t");
  Serial.println(WiFi.softAPIP());
}
void loop() {
}

ssid = Nombre de la red wifi a la que se conectará
password = Clave de la red

Se configura el módulo como AP para crear redes wifi y luego se pasan la variablen que contiene la configuración a la función WiFi.softAP(ssid, password) encargada de establecer la configuración en el módulo. Con esto ya podríamos verificar la existencia de una nueva red wifi con nombre y clave establecidos en cualquier dispositivo con conexión wifi.

Creando Socket TCP/IP

Un socket TCP-IP permite la comunicación de nuestra placa con cualquier software o aplicación. Crear uno es bastante facil. 

                    

#include <Arduino.h>
#include <ESP8266WiFi.h>

WiFiServer wifiServer(80);

void setup()
{
  Serial.begin(115200);
  WiFi.begin("ceenford-latinoamerica", "44442832");

  Serial.print("Connecting");
  while (WiFi.status() != WL_CONNECTED)
  {
    delay(500);
    Serial.print(".");
  }
  Serial.println();

  Serial.print("Connected, IP address: ");
  Serial.println(WiFi.localIP());
  
  wifiServer.begin();

}

void loop()
{
  WiFiClient client = wifiServer.available();
  if (client) {
    while (client.connected()) {
      while (client.available() > 0) {
        char c = client.read();
        Serial.write(c);
        delay(10);
      }
      client.write("HTTP/1.0 200 OK\r\nContent-Type: text/html\r\n\r\n");
      client.write("<html>"
                "<head>"
                    "<title>Motika By CVR ELECTRONICA</title>"
                "</head>"
                "<body style='margin: 0; padding: 0; background-color:black;'>"
                  "<div style='width: 100%; height:100%; position:absolute; display:flex; flex-direction:column; justify-content: center; align-items:center; background-color:black;'>"
                      "<h1 style='width: 100%; height: 100px; color: white; text-align:center;'>Servidor web CVR ELECTRONICA</h1>"
                      "<a href='https://cvrelectronica.com'><button style='width: 400px; height: 90px; background-color:#00ff22; color: black; border: none; outline:none; border-radius:10px; font-size:32px; cursor: pointer;'>IR A LA TIENDA CVRELECTRONICA.COM</button></a>"
                  "</div>"
                "</body>"
              "</html>"
              "\r\n\r\n");
      client.stop();
    }
    client.stop();
  }
  
}

Primero establecemos la conexión a la red wifi, luego esperamos la conexión de un cliente al socket donde se escuchará la conexión. Una vez reciibida la conexión en el puerto establecido con wifiServer(80) se responde con el código HTML que se muestra en el código como ejemplo.

Controlando Cargas:
Motika, cuenta con 4 relés mecánicos en placa con posibilidad de control de 8 canales de relé (P4-P7) y hasta 16 canales (agregando módulo de expansión de 8 canales extra) completamente aislados del microcontrolador y controlados por el módulo de expansión PCF8574. permitiendo el control de las cargas haciendo uso de solo 2 pines del microcontrolador (I2C). A continuación el código de muestra para el control de cargas mediante el uso de relés.

Para facilitar el uso de los relés en placa hemos desarrollado un script que se encarga del control de los mismos. Este script debe ser importado al archivo principal del proyecto para cargar sus funciones.
A continuación el escript chargesController.ino 

                

#include <Arduino.h>
#include <Wire.h>

byte direccion = 0x20;
char last_byte = 0;


Wire.begin(2,0);
PCF8574_clear();

void PCF8574_clear(){
  writeToPCF(0);
  last_byte = 0;
}

void writeToPCF(byte b){ //escribe los datos al pcf8574 modulo vía i2c
	Wire.beginTransmission(direccion);
  Wire.write(b);
  Wire.endTransmission();
}

void on_io(char pin){
  byte bases[] = {0x1,0x2,0x4,0x8,0x10,0x20,0x40,0x80};

  if(pin == 'a'){
    char nb = (0xFF & 255);
    writeToPCF(nb);
    last_byte = 255;
  }
  else if(pin > 0 && pin < 9){
    char nuevo = (bases[pin - 1] | last_byte);
    writeToPCF(nuevo);
    last_byte = nuevo;
    Serial.println(last_byte,10 );
  }
}

void off_io(char pin){
  char last_off = last_byte;
  byte bases_off[] = {0xFE,0xFD,0xFB, 0xF7,0xEF,0xDF,0xBF,0x7F};
  if(pin =='a'){
    writeToPCF(0);
    last_byte = 0;
  }
  else if(pin > 0 && pin < 9){
    char nuevo_off = (bases_off[pin -1] & last_off);
    writeToPCF(nuevo_off);
    last_byte = nuevo_off;
  }
}

byte get_io(){
  Wire.requestFrom(direccion, 1);
  byte c = Wire.read();
  return c;
}

Controlando cargas vía TCP-IP

Por ultimo, dejaremos un ejemplo completo en el que se mostrará como controlar cargas desde el modulo Motika desde cualquier cliente TCP/IP por medio de la red wifi.

Recuerda que esta es solo una pequeña aplicación para instruirte sobre como funciona la placa, pero con tu imaginación podrás hacer cualquier cosa.

                

#include <Arduino.h>
#include <Wire.h>
#include <ESP8266WiFi.h>

byte direccion = 0x20;
char last_byte = 0;

int count = 1 ;
char action = 'o';

WiFiServer wifiServer(80);

void setup()
{
  Wire.begin(2,0);
  Serial.begin(115200);
  WiFi.begin("ceenford-latinoamerica", "44442832");
  Serial.print("Connecting");
  while (WiFi.status() != WL_CONNECTED)
  {
    delay(500);
    Serial.print(".");
  }
  Serial.println();
  Serial.print("Connected, IP address: ");
  Serial.println(WiFi.localIP());
  
  wifiServer.begin();
}

void loop()
{
  WiFiClient client = wifiServer.available();
  if (client) {
    while (client.connected()) {
      while (client.available() > 0) {
        char c = client.read();
        switch(c){
          case 'A':
            on_io(1);
            break;
          case 'a':
            off_io(1);
            break;
          case 'B':
            on_io(2);
            break;
          case 'b':
            off_io(2);
            break;
          case 'C':
            on_io(3);
            break;
          case 'c':
            off_io(3);
            break;
          case 'D':
            on_io(4);
            break;
          case 'd':
            off_io(4);
            break;
        }
        Serial.write(c);
        delay(10);
      }
    }
    client.stop();
  }
  
}

void PCF8574_clear(){
    writeToPCF(0);
    last_byte = 0;
}

void writeToPCF(char byte){ //escribe los datos al pcf8574 modulo vía i2c
	  Wire.beginTransmission(direccion);
    Wire.write(byte);
    Wire.endTransmission();
}

void on_io(char pin){
    byte bases[] = {0x1,0x2,0x4,0x8,0x10,0x20,0x40,0x80};

    if(pin == 'a'){
        char nb = (0xFF & 255);
        writeToPCF(nb);
        last_byte = 255;
    }
    else if(pin > 0 && pin < 9){
        char nuevo = (bases[pin - 1] | last_byte);
        writeToPCF(nuevo);
        last_byte = nuevo;
    }
}

void off_io(char pin){
    char last_off = last_byte;
    byte bases_off[] = {0xFE,0xFD,0xFB, 0xF7,0xEF,0xDF,0xBF,0x7F};
    if(pin =='a'){
      writeToPCF(0);
      last_byte = 0;
    }
    else if(pin > 0 && pin < 9){
      char nuevo_off = (bases_off[pin - 1] & last_off);
      writeToPCF(nuevo_off);
      last_byte = nuevo_off;
    }
}