Experimentos con Arduino: septiembre 2014

sábado, 27 de septiembre de 2014

8051 en los paises en desarrollo

Si buscamos en internet información relacionada con los microcontroladores 8051/8052 podremos comprobar que existen una gran cantidad de páginas de la India, Filipinas, Malasia, Tailandia , etc , de hecho creo que son los países con mayor producción de blogs bajo este tema.

Como es normal, hay de todo, pero no deja de sorprenderme gratamente la cantidad de páginas de nivel hechas por gente muy joven , y en algunas de ellas se puede observar que el autor no dispone de muchos recursos para su elaboración, lo cual es aún mas meritorio.

La diferencia de precio entre un micro de mayores prestaciones y un 8051/8052 mas económico es de "apenas" dos o tres dólares. Para muchos de nosotros esta diferencia no es significativa, pero para un estudiante en Bangladesh (por ejemplo) seguramente si lo es.

Los proyectos que se pueden encontrar son de todo tipo y las soluciones técnicas que podemos ver son dignas de reconocimiento ( por ejemplo un detector de humo que consiste en un led y un fotodiodo dentro de un cilindro con una perforación por donde penetra el humo ).

Es bueno tomar en cuenta el reciente éxito de la India ( a la primera !!! ) al colocar en órbita sobre Marte un satélite de investigación. El proyecto costó menos que la película Gravity (sí, la mano de obra es mas económica que en occidente, pero es tecnología de la India y solo cuatro países han logrado esa hazaña).

Mi profundo respeto y reconocimiento para los jóvenes de estos países que con tan pocos recursos logran obtener resultados muy significativos utilizando tecnología que en otras partes seguramente se consideraría "obsoleta".

domingo, 21 de septiembre de 2014

8051 : Interfase at89S51 con eeprom 24C512

Los micros de la familia 8051/8052 no incluyen memoria eeprom; en el caso de los micros Atmega si se dispone de este tipo de memoria.

En el mercado hay disponibles memorias eeprom de interfase serial. Son chips muy económicos con capacidades de hasta 128KB y cuya conexión con el micro es a través del protocolo IC2 (serial basado en dos lineas de comunicación).

La memoria eeprom es útil cuando necesitamos guardar información y que la misma perdure aunque no tengamos conectada la fuente de alimentación al circuito. Un ejemplo muy conocido es un medidor de temperatura que registra las medidas durante un período de tiempo para luego realizar las observaciones pertinentes. La desventaja de estos chips es que la velocidad de escritura/lectura está en el orden de los milisegundos.

En nuestro ejemplo deseamos conectar una memoria Atmel 24C512 (64KB) con un micro at89s51.
En la imagen tenemos tres mini-protobroard . De izquierda a derecha:

Micro atmega644 funcionando como programador ISP (pueden observarse los cuatro cables) conectado a un ordenador a través del puerto serial (primera interfase serial/USB)
Micro at89S51 a 20MHz conectado mediante el puerto serie a un ordenador (segunda interfase serial/USB)
eeprom 24C512 con la dirección A0H (todos los pines a tierra).

La conexión de la memoria con el micro es la siguiente:

Pines 1,2,3,4 y 7 a tierra (GND)
Pin 8 a 5Voltios (Vcc)
Pin 5 a puerto P2.1 del micro ( se requiere una resistencia pullup de 10KOhms a Vcc)
Pin 6 a puerto P2.0 del micro ( se requiere una resistencia pullup de 10KOhms a Vcc)

A continuación un ejemplo de código en pascal que nos permite leer la memoria eeprom (el programa utiliza las unidades I2C y eeprom de Igor Funa Turbo51)

//  eeprom reader
//  Baud  Bits Parity Stop FlowControl
//  xxxx     8    N      1  none 
//  Led conected to port P0.0
//  20MHz -> 7200*2 = 14400 bauds

Program Calculator;
{$O+} 

Uses I2C,eeprom;

Const
  Osc = 20000000; 
  BaudRateTimerValue = Byte (- Osc div 12 div 32 div 7200);
 
Var 
    Led0: Boolean absolute P0.0;
    SerialPort: Text;
    range0,range1,range,y: longint;
    i,j,dec:byte; 
    address:word;
    hex: Array [0..1] of char;
    
    I2C.SCL:          Boolean absolute P2.1; Volatile;
    I2C.SDA:          Boolean absolute P2.0; Volatile;

Procedure WriteToSerialPort; Assembler;
Asm
  CLR   TI
  MOV   SBUF, A
  @WaitLoop:
  JNB   TI, @WaitLoop
end;
 
Function ReadFromSerialPort: Char;
Var ByteResult: Byte absolute Result;
begin
  While not RI do;
  RI := False;
  ByteResult := SBUF;
  { Echo character }
  Asm
    MOV    A, Result
    LCALL  WriteToSerialPort
  end;
end;

Procedure dec2hex;
const HexChar: Array [0..15] of Char  = '0123456789ABCDEF';
var   d0,r: integer;
begin
  d0:=dec div 16;
  r :=dec mod 16;
  hex[0]:=HexChar[r];
  hex[1]:=HexChar[d0];
end;
  
Procedure Init;
begin
  TL1  := BaudRateTimerValue;
  TH1  := BaudRateTimerValue;
  TMOD := 100001;     
  SCON := %01010000;     
  TI   := True;         
  TR1  := True;  
  PCON := PCON or $80; //SMOD=1   baud doubled to 9600        
end;

{$DefaultFile On}
begin
  Init;
  Assign (CurrentIO, ReadFromSerialPort, WriteToSerialPort);
  Repeat
    Writeln ('');
    Write  ('eeprom initial address: ');
    Read   (range0);Writeln('');
    Write  ('eeprom final address  : ');
    Read   (range1);Writeln('');
    range:=(range1 - range0) div 10;
    address:=range0;
    j:=1;
    for y:= 0 to range do   begin
      write (address:6 ,': '); 
      for  i:= 1 to 10 do   begin
        dec:=ReadByteFromEEPROM (address);
        dec2hex;
        write (hex[1],hex[0],' '  );
        address:=address+1;                                                              
      end;
      address:=address-10 ;
      write('  ');
      for  i:= 1 to 10 do   begin
        dec:=ReadByteFromEEPROM (address);
        if (dec>31)  then write (chr(dec)) 
        else              write ('.') ;
        address:=address+1;
      end;
      j:=j+1;
      if (j>40) then begin
         writeln('');
         read(hex);
         j:=1;
      end;
      writeln('');
      Led0:=not(Led0);
    end;  
  until False;
end.

A continuación la unidad I2C:

{
    This file is part of the Turbo51 examples.
    Copyright (C) 2008 - 2011 by Igor Funa

    http://turbo51.com/

    This file is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
}

Unit eeprom;

Interface

Uses I2C;

Procedure Check_EEPROM_Status;
Procedure WriteByteToEEPROM (Address: Word; D: Byte);
Function ReadByteFromEEPROM (Ad: Word): Byte;
Function ReadBytesFromEEPROM: LongInt;

Implementation

Const eeprom_add = $A0;

Procedure Check_EEPROM_Status;
Var EEPROM_Counter: Word;
begin
  For EEPROM_Counter := 1 to 2000 do
    begin
      Start_I2C;
      Send_I2C_Byte (eeprom_add);
      If Ack then Exit;
      Asm
        NOP
        NOP
      end;
    end;
end;

Procedure WriteByteToEEPROM (Address: Word; D: Byte);
begin
  Check_EEPROM_Status;
  Send_I2C_Byte (Hi (Address));
  Send_I2C_Byte (Lo (Address));
  Send_I2C_Byte (D);
  Stop_I2C;
end;

Function ReadByteFromEEPROM (Ad: Word): Byte;
begin
  Check_EEPROM_Status;
  Send_I2C_Byte (Hi (Ad));
  Send_I2C_Byte (Lo (Ad));
  Start_I2C;
  Send_I2C_Byte (eeprom_add or $01);
  ReadByteFromEEPROM := Receive_I2C_Byte;
  Stop_I2C;
end;

Function ReadBytesFromEEPROM: LongInt; Assembler;
Asm
  LCALL     Check_EEPROM_Status

  MOV       Send_I2C_Byte.Data2Send, DPH
  LCALL     Send_I2C_Byte

  MOV       Send_I2C_Byte.Data2Send, DPL
  LCALL     Send_I2C_Byte

  LCALL     Start_I2C

  MOV       Send_I2C_Byte.Data2Send, #0A3H
  LCALL     Send_I2C_Byte

  LCALL     Receive_I2C_Byte
  MOV       R0, A
  LCALL     Send_I2C_Ack;
  LCALL     Receive_I2C_Byte
  MOV       R1, A
  LCALL     Send_I2C_Ack;
  LCALL     Receive_I2C_Byte
  MOV       R4, A
  LCALL     Send_I2C_Ack;
  LCALL     Receive_I2C_Byte
  MOV       R5, A
  LCALL     Send_I2C_ClockPulse;
  MOV       R2, AR0
  MOV       R3, AR1

  LCALL     Stop_I2C
end;

end.

A continuación la unidad eeprom:

{
    This file is part of the Turbo51 examples.
    Copyright (C) 2008 - 2011 by Igor Funa

    http://turbo51.com/

    This file is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
}

Unit I2C;

Interface

Const HighLevel = True;
      LowLevel  = False;

Var Ack: Boolean;
    SDA: Boolean absolute Forward; Volatile;
    SCL: Boolean absolute Forward; Volatile;

Procedure Start_I2C;
Procedure Stop_I2C;
Procedure Send_I2C_Byte (Data2Send: Byte);
Function  Receive_I2C_Byte: Byte;
Procedure Send_I2C_Ack;
Procedure Send_I2C_ClockPulse;

Implementation

Procedure Start_I2C;
begin
  SCL := HighLevel;
  Asm
    NOP
  end;
  SDA := LowLevel;
  Asm
    NOP
  end;
  SCL := LowLevel;
  Asm
    NOP
  end;
end;

Procedure Stop_I2C;
begin
  SDA := LowLevel;
  Asm
    NOP
  end;
  SCL := HighLevel;
  Asm
    NOP
  end;
  SDA := HighLevel;
  Asm
    NOP
  end;
end;

Procedure Send_I2C_Byte (Data2Send: Byte);
Var BitCounter: Byte;
begin
  For BitCounter := 1 to 8 do
    begin
      SDA := Data2Send and $80 <> 0;
      Asm
        NOP
      end;
      SCL := HighLevel;
      Asm
        NOP
      end;
      SCL := LowLevel;
      Asm
        NOP
      end;
      Data2Send := Data2Send shl 1;
    end;
  SDA := HighLevel;
  Asm
    NOP
  end;
  SCL := HighLevel;
  Asm
    NOP
  end;
  Ack := not SDA;
  SCL := LowLevel;
  Asm
    NOP
  end;
end;

Function Receive_I2C_Byte: Byte;
Var Data: Byte;
    BitCounter: Byte;
begin
  Data := 0;
  For BitCounter := 1 to 8 do
    begin
      SCL := HighLevel;
      Asm
        NOP
      end;
      Data := Data shl 1;
      Data := Data or Byte (SDA);
      SCL := LowLevel;
      Asm
        NOP
      end;
    end;
  Receive_I2C_Byte := Data;
end;

Procedure Send_I2C_Ack;
begin
  SDA := LowLevel;
  Asm
    NOP
  end;
  SCL := HighLevel;
  Asm
    NOP
  end;
  SCL := LowLevel;
  Asm
    NOP
  end;
  SDA := HighLevel;
  Asm
    NOP
  end;
end;

Procedure Send_I2C_ClockPulse;
begin
  SCL := HighLevel;
  Asm
    NOP
  end;
  SCL := LowLevel;
  Asm
    NOP
  end;
end;

end.

Ambas unidades deben ser compiladas y los archivos con extensión .u51 deben copiarse en la misma carpeta donde se encuentra el ejecutable turbo51.exe
En la imagen un ejemplo de lectura de los posiciones 100 a 400 (decimal) mostrado en el terminal:

domingo, 14 de septiembre de 2014

8051 : Atmel 89S51 , programación en Pascal

La programación de microcontroladores en Pascal no es común, sin embargo para la familia 8051 existe el compilador Turbo51 el cual tiene unas características muy interesantes.

Normalmente se considera el lenguaje C como el mas eficiente en cuanto a tamaño y calidad del código binario creado , asi como también en cuanto a velocidad de ejecución. Si comparamos el compilador SDCC con Turbo51 los papeles se invierten. De hecho el código binario creado por Turbo51 está muy optimizado en cuanto a tamaño y velocidad de ejecución, es por ello que vale la pena experimentar con este compilador.

Al igual que en el caso de otros compiladores se requiere un editor/IDE para poder crear programas y posteriormente compilarlos. Una opción muy sencilla es el editor de programación PSPAD

La parametrización de PSPAD consiste en modificar la pestaña

Opciones -> Configurar Resaltadores :

Una vez creado el programa fuente en el editor debemos compilarlo :

El resultado de la compilación se muestra en la sección inferior de la pantalla. Si la compilación es exitosa se genera el mensaje Exit code = 0

El archivo binario .hex se crea en la misma carpeta donde tenemos el programa fuente.

A continuación un ejemplo que permite generar los primeros 47 números de fibonacci, lucas y el número mágico "golden section" y los muestra por el puerto serial (utilizamos un cristal de 24Mhz y la velocidad de conexión con el terminal es de 4800x2=9600bauds):

Program Fibonacci;
{$O+} 

Const
  Osc = 24000000;
  BaudRateTimerValue = Byte (- Osc div 12 div 32 div 4800);
  digit : Array [0..9] of Byte = ($C0,$F9,$a4,$b0,$99,$92,$83,$f8,$80,$98);
 
Var 
    SerialPort: Text;
    a,b,c,la,lb,lc,max,i,j:LongInt;
    r:Real;
 
Procedure WriteToSerialPort; Assembler;
Asm
  CLR   TI
  MOV   SBUF, A
  @WaitLoop:
  JNB   TI, @WaitLoop
end;
 
Function ReadFromSerialPort: Char;
Var ByteResult: Byte absolute Result;
begin
  While not RI do;
  RI := False;
  ByteResult := SBUF;
  { Echo character }
  Asm
    MOV    A, Result
    LCALL  WriteToSerialPort
  end; 
end;
 
 
Procedure Init;
begin
  TL1  := BaudRateTimerValue;
  TH1  := BaudRateTimerValue;
  TMOD :=    100001;  
  SCON := %01010000;     
  TI   := True;         
  TR1  := True; 
  PCON := PCON or $80; //SMOD=1  por lo que dobla el baud a 9600    
  Assign (CurrentIO, ReadFromSerialPort, WriteToSerialPort);   
end;
 
{$DefaultFile On }
 
begin
  Init;
 
  Writeln ('Fibonacci Number LS');
  Repeat
    Write   ('Enter max Fibonacci number: ');
    Read   (max);Writeln('');
    if (max>46) then max:=46;
    a:=1;
    b:=1;
    la:=2;
    lb:=1;
    writeln(1:3,' F:',a:12,' L:',la:12,'  GS:');
    writeln(2:3,' F:',b:12,' L:',lb:12,'  GS:');
    j:=3;
    for i:=3 to max do  begin;
       c:=(a+b);
       lc:=(la+lb);
       writeln(i:3,' F:',c:12,' L:',lc:12,'  GS:',c/b:12:10);
       a:=b;
       b:=c;
       la:=lb;
       lb:=lc;
       P0:=digit[j];
       j:=j+1;
       if j>9 then j:=0;
    end;
    writeln('  Golden Section: ',(Sqrt(5.0)+1.0)/2.0:12:10);
  until False;
end.

Una vez creado el archivo binario .hex debemos grabarlo en la memoria flash del micro mediante un programador (en nuestro caso utilizamos un Arduino ATmega644 en modo programador SPI).

En este ejemplo podemos ver lo eficiente que es el compilador ya que el tamaño del binario creado es de 2733B , un número impresionante si tomamos en cuenta que tenemos cargadas las librerías para impresión con formato y utilizamos números de punto flotante.

8051 : Atmel 89S51 , programación en C

El lenguaje de alto nivel C es sin lugar a dudas el mas utilizado en la progamación de microcontroladores.
En el mercado existen muchos compiladores C para la familia 8051, uno de ellos es SDCC .
Para poder crear un programa en C tenemos que utilizar un editor o un IDE que puedan ser parametrizados para el compilador.

Una opción es el editor para programación PSPAD.
La parametrización de PSPAD es muy sencilla, debemos configurar la pestaña:
Opciones -> Configurar Resaltadores :

En la imagen podemos ver que se modifica la pestaña Compilador.

El último campo (Ejecutar después de compilar) permite generar el archivo binario hex que va a ser cargado en el micro, ya que el compilador por defecto crea un archivo binario con extensión ihx

Una vez creado el programa debemos compilarlo mediante el botón mostrado en la figura:

El resultado de la compilación se muestra en la sección inferior de la pantalla. Una compilación exitosa genera un Exit code = 0

El archivo binario .hex se crea en la misma carpeta donde tenemos el programa fuente.

A continuación un ejemplo que permite generar los primeros 47 números de fibonacci y los muestra por el puerto serial:

/*
  Clock 24Mhz
  9600 8 N 1 None    con  PCON|=0x80;
  4800 8 N 1 None    sin  PCON|=0x80;
  
  print_tiny consume poca memoria pero no tiene %lu ni %f
  print_fast_f consume 1.4 KB y tiene %lu pero no tiene %f
  print_fast_f_ consume mucha memoria y tiene %lu y %f
*/

#include <at89x51.h>  
#include <stdio.h> 

void serial_init()
{
 PCON|=0x80; //SMOD=1
 SCON=0x50;
 TMOD=0x20;
 TH1=0xF3;
 TR1=1;
 TI=1;
}
     
void putchar (char c) 
{
  SBUF = c;
  while (!TI) ;                                    
  TI = 0;
}

char getchar()
{
   char chr;        
   while (RI == 0) {;}
   chr = SBUF;
   RI = 0;
   return(chr); 
}

void main()
{
  __code unsigned char msg0[]="\n\r\n\rFibonacci Numbers: \n\r";
  int i;
  unsigned long  f0,f1,f2;
  unsigned char ch;
  serial_init();
  
  printf_fast_f(msg0);
  f0=1;
  f1=1;
  printf_fast_f ("%4d  %12d   \n\r", 1,1 );   
  printf_fast_f ("%4d  %12d   \n\r", 2,1 );   
  for(i=3;i<48;i++)  {
           f2=f0+f1;
           printf_fast_f ("%4d  %12lu   \n\r", i,f2 );   
           f0=f1;
           f1=f2;
  }
  ch=getchar();
}

Una vez creado el archivo binario .hex debemos grabarlo en la memoria flash del micro mediante un programador (en nuestro caso utilizamos un Arduino ATmega644 en modo programador SPI).

Es importante tener en cuenta que estamos trabajando con la memoria interna del micro, por lo que sólo disponemos de 4KB de flash y 256B de RAM. Esto impone restricciones importantes en cuanto a los programas que podemos ejecutar. De hecho no es factible cargar librerías de punto flotante ya que los requerimientos exceden la memoria flash disponible. En el ejemplo el archivo binario creado tiene un tamaño de 2129B y sólo utilizamos la libreria <stdio.h>

jueves, 11 de septiembre de 2014

8051 : Atmel 89S51

La empresa Atmel, fabricante del micro utilizado en los Arduino, dispone de varias familias de microcontroladores con diferentes arquitecturas y características.

Una de éstas es la familia 8051 de 8bits, la cual emula al famoso MCS-51 de Intel.

El chip original de Intel fue muy popular en su época y hoy en día existen varias empresas que producen chips con su estructura.

A pesar del avance en las funcionalidades de los micros disponibles en la actualidad y de la popularidad de chips como los AVR de Atmel y los PIC de Microchip, los descendientes del 8051 cuentan con un grupo importante de seguidores. La razón de ello es su simplicidad y la disponibilidad de una gran cantidad de recursos en la web para estos micros (lenguajes, emuladores, documentación, desarrollos, etc).

El micro at89s51 es una de las versiones producidas por Atmel en su familia 8051.

Como podemos leer en su hoja de especificaciones cuenta con las siguientes características:

4KB de memoria flash
128B de memoria ram
32 puertos binarios de entrada/salida
Interfase serial UART
Programación de la memoria flash mediante protocolo ISP
Dos contadores/relojes de 16 bits
Seis interrupciones
Operación estática desde 0 a 33 MHz

Lamentablemente no posee puertos analógicos ni PWM (pero se puede emular por software).

Este micro puede disponer de dos bancos de 64KB de memoria externa para programas y data (hay que recordar que es un micro con arquitectura Harvard) .

Una característica interesante de este micro es la capacidad de programar la memoria flash mediante el protocolo ISP.

En el caso del Arduino el procedimiento para programar el micro at328 es muy sencillo ya que consiste en crear el programa en el IDE y presionar el boton de Carga. Esta es una de las características que ha hecho tan popular esta plataforma.

En el caso de la familia 8051 el procedimiento es algo mas complicado:

Debe utilizarse un IDE que permita crear el programa y compilarlo (hay disponibles compiladores c, pascal, forth, assembler, etc).
El compilador genera un archivo binario en formato hex
Este archivo debe ser grabado en el micro mediante otro programa que se comunica con el programador (existen muchos circuitos de ejemplo en la red)

Originalmente se utilizaba el lenguaje assembler para programar estos micros, pero con el tiempo se desarrollaron compiladores de lenguajes de alto nivel como c y pascal.

Una lista resumida de compiladores sería:

Assembler : ASEM-51
C : SDCC , Keil , mikroC
Pascal : Turbo 51 , mikroPascal

Entre los IDE disponibles en la web tenemos:

MIDE-51 Studio : Incluye editor, compilador C (SDCC) , ensamblador (ASEM-51) y dos emuladores (JSIM-51 y una versión limitada a 2K de TS Control Emulator 8051)
MCU 8051 IDE : Incluye editor, compilador C (SDCC) , ensamblador (propio y dos adicionales), emulador , cargador de hex (circuito propio) y muchas herramientas adicionales.
Turbo51 Studio : Incluye editor, compilador pascal (Turbo 51) , ensamblador ( ASEM-51), emulador , cargador de hex (circuito propio) y varias herramientas adicionales.
Reads51 : Incluye editor, compilador c (propio) , ensamblador ( propio) y emulador

Páginas