miércoles, 6 de mayo de 2020

AVR IoT Light Sensor

La tarjeta AVR IoT cuenta con el sensor de luz ambiental TEMT6000  un foto-transistor PNP adaptado a la respuesta del ojo humano.

Según el circuito esquemático la salida del sensor esta en el PD5 y su equivalente en arduino en el 17 o A5.
El atmega4808 tiene un conversor Analógico / Digital de 10 bits por tanto tendremos lecturas de 0 a 1023 en un rango de voltaje de 0 a 3,3 Vdc
Esto produce una resolución de lectura de 3,2 mV



















//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*
AVR IoT includes the TEMT6000 ambient light sensor on board.
A PNP photo transistor adapted to the response of the human eye.
In the schematic circuit, the sensor output is on the PD5 and its equivalent in arduino pin 19 or A5.
*/
void setup() {
  // initialize serial2 communication at 115200 bits per second:
  Serial2.begin(115200);
}


void loop() {
  // read the input on analog pin 0:
  int lux = analogRead(A5); // Pin PD5  atmega 4808
  // print out the value you read:
  Serial2.println(lux);
  delay(500);        // delay in between reads for stability
}

domingo, 16 de febrero de 2020

Arduino en Atmega AVR 0 Series

Desde hace un tiempo tengo en mis manos dos tarjetas de desarrollo la AVR-IoT con el Atmega 4808 y la curiosity Nano Atmega 4809
La primera desarrollada para funcionar inicialmente con los servicios de Google ( luego con el tiempo esto fue cambiando a una mayor diversidad). Cuenta con el modulo WiFi WINC1510, sensor de Luz, sensor de temperatura e IC de de seguridad/encriptación. También cuenta con su propio programador abordo y conector para alimentación a batería de litio con su etapa de carga.

La Curiosity Nano  mas de 40 pines I/O cuenta con cristal 32 KHz para implementar aplicaciones RTC, También tiene programador/ depurador a bordo.

La idea en esta serie realizar una serie de tutoriales con estas tarjetas basada en Arduino.

Y aqui empezamos. Para ello nos basamos en la libreria MCUdude / MegaCoreX. La documentación completa aqui ===>>> https://github.com/MCUdude/MegaCoreX

Para ello abrimos nuestro IDE Arduino y en la pestaña File / Preferences / Additional Boards Manager URLs: pegamos el siguiente enlace:
https://mcudude.github.io/MegaCoreX/package_MCUdude_MegaCoreX_index.json
Luego nos vamos Open the Tools > Board > Boards Manager...  esperamos que actualice el listado y si nos desplazamos ya debe aparecer MegaCorex by MCUdude instalamos y ya estamos listos hasta los momentos.

Ahora veremos nuestro Pinout
El AVR-IOT WG utiliza el ATmega4808 en un encapsulado de 32 pines. El estándar de 32 pines es el pinout correcto para esta placa. Hay que tener en cuenta que el puerto serial UART2 está conectado al chip depurador. Esto significa que tendrá que usar Serial2.begin (baudios) para imprimir en el monitor serial. También tendrá que elegir Atmel nEDBG (ATSAMD21E18) como su programador para cargar el código.
En el pinout aparece en color celeste los pines compatibles con Arduino en el conector MiKroBus al igual que los botones y los leds. Mas adelante con el squematico en mano tambien les enseñare los pines conectados al Modulo WINC1510.

Ahora vamos con el "Hola Mundo"
Lo ajustaremos de la siguiente manera




////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#define BlueLed 15 // El Led azul de la placa AVR-IoT

void setup() {
  // Inicializa el puerto serial en este caso el puerto serial 2
  Serial2.begin (9600);
  // Inicializa el led azul como salida
  pinMode(BlueLed, OUTPUT);
  Serial2.println ("Empezamos");
  delay(3000); 
  
}

void loop() {
  digitalWrite(BlueLed, LOW);   // el Led se enciende en bajo debido a que los leds de la placa están alimentados a Vdd
  Serial2.println("El Led azul está encendido");
  delay(2000);                       // espera por 2 segundos
  digitalWrite(BlueLed, HIGH);    // el Led se apaga en alto debido a que los leds de la placa están alimentados a Vdd
  Serial2.println("El Led azul está apagado");
  delay(2000);                       // espera por 2 segundos
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


Segundo ejemplo incluyendo todos los leds a bordo



#define BlueLed 15 // El Led azul de la placa AVR-IoT
#define GreenLed 14 // El Led verde de la placa AVR-IoT
#define YellowLed 13 // El Led amarillo de la placa AVR-IoT
#define RedLed 12 // El Led rojo de la placa AVR-IoT

void setup() {
  // Inicializa el puero serial en este caso el puerto serial 2
  Serial2.begin (9600);
  pinMode(BlueLed, OUTPUT);
  pinMode(YellowLed, OUTPUT);
  pinMode(GreenLed, OUTPUT);
  pinMode(RedLed, OUTPUT);
  Serial2.println ("Empezamos");
  delay(3000); 
  
}

void loop() {
  digitalWrite(BlueLed, LOW);
  delay(500);   
  digitalWrite(GreenLed, LOW);
  delay(500);                    
  digitalWrite(YellowLed, LOW);
  delay(500);
  digitalWrite(RedLed, LOW);
  delay(500);
  digitalWrite(BlueLed, HIGH);
  delay(500);   
  digitalWrite(GreenLed, HIGH);
  delay(500);                       
  digitalWrite(YellowLed, HIGH);
  delay(500);       
  digitalWrite(RedLed, HIGH);
  delay(500);   
}

sábado, 6 de octubre de 2018

Uso de un viejo display VFD de comunicación serial UART para usarlo con IDE Arduino

Tengo muy poco tiempo estudiando el tema de los microcontroladores y como muchos he empezado con Arduino. Después de realizar algunos tutoriales básicos, me interesó más el tema y seguí investigando con los microcontroladores AVR con el cual está fundamentado el Arduino Uno. Hasta el momento he invertido tiempo y dinero en algunas placas de desarrollo AVR, PIC, ARM y Espressif. 

No siempre voy a tener todos los recursos para manejar ciertos periféricos o hardware como pasa en todos los tutoriales de Arduino donde generalmente te venden el hardware con un link de una librería lista para usarla en la IDE hasta con ejemplos. Y esto fue lo que me pasó cuando me conseguí al despiezar un Pedalboard de efectos de guitarra el cual tiene un Display del tipo VFD. Este tipo de displays son los más usados en nuestros dispositivos electrónicos caseros como lo son los equipos de sonidos, microondas, etc.

El display en cuestión es el Futaba M202SD01. Googleando conseguí el datasheet. Para poder comprender las conexiones y saber qué tipo de comunicación disponía. Revisando en pinout observo que dispone de comunicación paralela y serial. Pero ninguna de ellas era parecida a las que me conocía con el display 16x2 que normalmente usamos en los tutoriales. En ese momento empieza el trabajo duro de investigar cómo podía utilizar mi viejo VFD con el Arduino. Me pareció muy complicado usar la comunicación paralela (y aparte de que usa más pines y recursos de mi placa) así que decidí enfocarme en la comunicación serial y no “no es I2C” usa comunicación serial UART un standard de comunicación serial asincrónica. (TX , RX) En el datasheet indica que se puede comunicar a una velocidad de 9600 baudios o 1200 baudios. 

En las primeras pruebas conecté el pin RX en la salida TX de mi placa Arduino y usando la función de monitor serie a 9600 pude imprimir caracteres en el display. (Ya me estoy acercando).
Ya que Arduino ofrece muchos recursos indagué en la parte de comunicación UART y conseguí una librería que me sirve para comunicarse con dispositivos de comunicación serial UART y esta es la librería "SoftwareSerial".
Ya lograda la comunicación me faltaba generar las funciones en el IDE Arduino con la información del fabricante, como se muestra a continuación:
En el datasheet que dejo para que descarguen sale la información completa.

Codigo y datasheet VFD Futaba



Simple alimentación a 5 V y el conector de datos UART

                                                           Algunos usos que les pude dar                                                         
Reloj
Muestra temperatura y Humedad
Medidor de distancias

Siguenos en twitter @e_SmartLabs



Las funciones quedaron así:

/////////////////////////////////////////////////////////////////////////////////////////////
// Funciones para la operación del VFD Futaba M202SD01LJ //
///////////////////////////////////////////////////////////////////////////////////////////

void VFDreset() // Todos los caracteres que se muestran se borran,
//luego la posición de escritura se establecerá en el dígito más significativo de la primera fila.
//El estado de visualización es el mismo que el reinicio de encendido,
//y el modo de cursor está configurado para el modo de iluminación, el nivel de Dimmer se establece en 100%.
{
  VFD.write(0x1F);
}

void VFDclear() // Todos los caracteres mostrados se borran,
//La posición de escritura se mueve al dígito más significativo de la primera fila.
//Pero el nivel de Dimmer y el modo de cursor se mantienen.
{
  VFD.write(0x0D); // clear display
}

void VFDdimmer(int amount) // El brillo se puede controlar en seis niveles usando esta función.
//Después de escribir 04H, se escriben los siguientes datos de atenuación para cambiar la corrección de salida.
//porcentaje de brillo de 0 hasta 255
{
  VFD.write(0x04);
  VFD.write(amount);

  switch (amount)
  {

    case 20:
      VFD.write(0x04); // clear
      VFD.write(0x20); // 20% Dimmer
      break;
    case 40:
      VFD.write(0x04); // clear
      VFD.write(0x40); // 40% Dimmer
      break;
    case 60:
      VFD.write(0x04); // clear
      VFD.write(0x60); // 60% Dimmer
      break;
    case 80:
      VFD.write(0x04); // clear
      VFD.write(0x80); // 80% Dimmer
      break;
    case 100:
      VFD.write(0x04); // clear
      VFD.write(0xFF); // 100% Dimmer
      }
}

void VFDchars() // Corren los carateceres UFO desde el 21 hasta el 255 descritos en el datasheet
{
  for (int i = 21 ; i < 256; i++)
  {
    VFD.write(i);
    delay(30);
  }
}

void setCursor(byte position) // Esta funcion permite mover el cursor del display desde 0  al 19
//y en la fila de abajo desde el 20 al 39
{
  VFD.write(0x10); // move cursor
  VFD.write(position); // location
}

void VFDbackspace ()
{
  VFD.write (0x08);
  //La posición de escritura se desplaza al dígito izquierdo y se borrará el carácter mostrado anteriormente en el dígito.
}

void VFDhorizontaltab()// la posicion de escritura se desplaza hacia la derecha
{
  VFD.write (0x09);
}

void cursormode (int amount ) // El cursor siempre se muestra en la posición de escritura.
//El cursor está formado por los 5 puntos ubicados en la parte inferior de la fuente de caracteres de matriz de puntos de 5 × 7.
// VFD cursor mode - FF Lighting/  88 Blinking/    00 No Lighting
{
  VFD.write(0x17);
  VFD.write(amount);
  switch (amount)
  {
    case 255: // fijo iluminad0
      VFD.write(0x17); // clear
      VFD.write(0xFF); // Lighting
      break;
    case 88: // Parpadeando
      VFD.write(0x17); // clear
      VFD.write(0x88); // Blinking
      break;
  }
}

void VFDall()  //Se ilumina toda la pantalla
{
  VFD.write (0x0F); // luego de usar la función hay que resetear el VFD
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


Si les interesa descarguen el código .ino
Si tiene alguna duda estamos aquí para ayudarnos de igual modo si pueden ayudar a mejorarlo "bienvenido sea" por los momentos no creí necesario crear una librería porque realmente no creo hayan muchas unidades por allí ya que ese display es de 1998.

Si se dieron cuenta use una versión de Arduino Uno DIY, de eso no haré tutorial les paso el link de Instructables  Homemade Arduino

El Datsheet al parecer no esta revisado hay algunas diferencias de los caracteres de dice el datasheet y los que muestra realmente con los comandos específicos de la ultima pagina. Por esta razón también desistí de la función Define Character (caracteres personalizados) intenté de varias maneras sin resultados satisfactorios.


También les informo que este es mi primer Blog que realizo oficialmente, espero ir mejorando a la medida que siga aprendiendo y publicando mas material. 







AVR IoT Light Sensor

La tarjeta AVR IoT cuenta con el sensor de luz ambiental TEMT6000  un foto-transistor PNP adaptado a la respuesta del ojo humano. Según el...