Experimentos con Arduino: 2014

domingo, 5 de octubre de 2014

Simulación de controlador PID en micro 8051

Los controladores PID (Proporcional/Integral/Derivativo) (wikipedia) son muy utilizados para controlar procesos de todo tipo.

Existe mucha documentación en la web donde se explica la teoría asociada y desarrollos tanto analógicos como discretos.

Simplificando podemos decir que la idea es medir un valor y compararlo con el valor deseado. En base a la diferencia de ambos valores (error) se genera una señal de ajuste para lograr que el valor medido se aproxime al valor deseado. El valor de ajuste se calcula mediante tres componentes :

Proporcional : Basado en el error actual (presente)
Integral : Basado en el historial de errores (pasado)
Derivativo : Basado en la proyección del error (futuro)

Vajuste = Kp * Proporcional + Ki * Integral + Kd * Derivativo

Las constantes de cada factor de la fórmula se seleccionan para determinar la curva de respuesta mas adecuada al proceso a controlar.

Cuando queremos utilizar un micro como controlador PID se utiliza un algoritmo discreto (se mide a ciertos intervalos de tiempo el valor de salida, se calcula el ajuste y se aplica la corrección).

A continuación tenemos un programa en pascal que permite simular el algoritmo PID en un micro de 8bits:

//   PID controller simulation

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

Program PID;
{$O+} 

Const
  Osc = 20000000; 
  BaudRateTimerValue = Byte (- Osc div 12 div 32 div 7200);
  UMAX= 0.2;   //Superior range
  UMIN=-0.2;   //Inferior range 
 
Var 
    SerialPort: Text;
   
    DelayTimer: Word; Volatile;
    control,set_point,measured_value,actual_error,error_previous:real;
    Pc,Ic,Dc:real;
    Kp,Ki,Kd:real;
    r:real;
    
Procedure Delay (DelayTime: Word);
var i,j:word;
begin
  for i:= 0 to DelayTime do   begin
    for j:= 0 to 32000 do begin end;
  end;
end;    

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 de la fórmula inicial
  Assign (CurrentIO, ReadFromSerialPort, WriteToSerialPort);         
end;
 
{$DefaultFile On }

begin
  Init;
  Randomize;
  
  Writeln ('Discrete PID simulation');
  Kp:=10;
  Ki:=1;
  Kd:=1;
  set_point:=10.5;      //Desired Value
  measured_value:=5.5;  //Initial value
  error_previous:=set_point - measured_value;  //Initial error
  Ic:=0;
  r:=0;
  Writeln ('Desired Value:',set_point:10:5);
  Repeat
    actual_error   := set_point - measured_value; 
   
    Pc := actual_error;   //Current error
    Ic := Ic + error_previous;  //Sum of previous errors
    Dc :=  error_previous - actual_error ;  //Difference with previous error
    control:= Kp*Pc + Ki*Ic + Kd*Dc; 
    if (control > UMAX) then control := UMAX;    
    if (control < UMIN) then control := UMIN;
    error_previous := actual_error;  //error_previous holds the previous error
    writeln ('Measured Value=',measured_value:10:5,' Control=',control:7:3, 
             '  Pc:',Pc:10:5,' Ic:',Ic:10:5,' Dc:',Dc:10:5,' R:',r:10:5);
    delay(2);
    r:=random(100)/500;   // random interference
    measured_value:= measured_value + control + r ;
  until False;
end.

En la imagen se muestra la salida de la simulación donde se puede observar como el valor medido se va incrementando:

En la siguiente imagen podemos ver que el valor medido ya se aproximó al valor deseado, desplazándose hacia arriba y hacia abajo dependiendo del valor de interferencia r .

Es interesante ver como los factores Proporcional/Integral/Derivativo varían a lo largo de la simulación.

Algunos enlaces interesantes:

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

sábado, 30 de agosto de 2014

Nostalgia : SDK-85

Allá por los remotos años 1970-1980 , cuando los microprocesadores estaban en su infancia, los aficionados y profesionales de la electrónica tenían a su disposición lo que se denominaba SDK (System Developtment Kit) . Eran kits para armar y que permitían experimentar con esta nueva tecnología.

Uno de estos kits es el SDK-85 (1977) de la empresa INTEL .

El microprocesador utilizado es el 8085. Este micro tenía varias características que lo distinguían de su antecesor, el 8080, entre las que cabe resaltar: fuente de alimentación única a 5Voltios, puerto serial, manejo de perifericos externos mas sencillo, etc.

El kit contenía cuatro chips:

El micro 8085 a 3Mhz
Chip de memoria RAM : 256bytes + puertos de E/S
Chip de memoria ROM: 2Kbytes + puertos de E/S . En el ROM venía pregrabado lo que se conocía como un programa "monitor", que permitía manipular la memoria RAM para cargar programas en hexadecimal.
Chip para controlar un display de leds 7 segmentos de seis dígitos y un teclado de 24 teclas

Las dimensiones de la tarjeta eran 30.5cm x 25.7cm e incluía un área de expansión para agregar mas circuitos.

En la imagen podemos ver un kit al que se la ha incluido 3Kbytes de memoria RAM , un segundo chip RAM de 256bytes y un EPROM de 2Kbytes con un "monitor" mejorado que incluye comunicación serial. A raíz de la ampliación fue necesario agregar alimentación de +12Voltios y -12Voltios.

Lo mas complicado es el proceso de carga de programas. Si queremos utilizar el EPROM (memoria borrable mediante luz ultravioleta), tenemos que disponer de una lámpara UV especial para el borrado (aproximadamente media hora) y el grabador respectivo. Si utilizamos la memoria RAM el programa se borra al desconectar la alimentación. Hay que recordar que la carga de programas era en formato hexadecimal, ya que se programaba en el lenguaje ensamblador del micro (el nivel mas bajo de programación).

Comparemos esto con un Arduino actual:

Micro a 16 MHz con 32KB de memoria flash, 2KB memoria RAM y 1KB memoria ROM
Los programas se cargan mediante interfase USB al PC
Se utiliza una versión del lenguaje C para la programación
Alimentración a pilas
Dimensiones 7cm x 5.5 cm

Que diferencia !!!

Pero de todas formas cuanta nostalgia por aquellos años locos !!!

sábado, 23 de agosto de 2014

Arduino Leonardo ISP

Un uso muy interesante del Arduino UNO es como ISP (in system programmer), es decir, programador de chips . Existe mucha información en la web al respecto.

Sin embargo, si en lugar del UNO tenemos el Leonardo, debemos hacer algunos "ajustes" para poder utilizarlo como ISP.

El enlace de PeterVH suministra la información requerida.

Un resumen del procedimiento sería:

Cargar en el IDE el programa ArduinoISP y modificar las líneas

#define RESET SS

#define LED_HB 9

por

#define RESET 10

#define LED_HB 13

Grabar el programa en el Leonardo
Crear un nuevo subdirectorio llamado leofix dentro del directorio hardware del IDE (..\hardware\leofix)
Crear un archivo txt dentro de este directorio llamado programmers.txt con el siguiente contenido:

arduinoispleo.name=Arduino as ISP (Leonardo)
arduinoispleo.communication=serial
arduinoispleo.protocol=arduino
arduinoispleo.speed=19200

Al invocar de nuevo el IDE tendremos en el menú Herramientas/Programador una nueva opción, la que hemos creado en el apartado anterior.
Lo recomendable es utilizar el conector ICSP de seis pines para conectar el Leonardo con el chip al cual se le desea grabar el programa. Los pines a usar son :

Pin 1 MISO (Superior izquierdo)
Pin 2 Vcc
Pin 3 Sck
Pin 4 MOSI
Pin 6 Gnd
El Pin 5 (Reset) no se utiliza. En su lugar usamos el puerto 10 del Leonardo conectado con el pin de Reset del chip a programar

Una vez hecha la conexión entre el Leonardo y el chip seleccionamos en el IDE la tarjeta correspondiente a este último y procedemos a grabar el programa (opción Archivo/Cargar programa usando programador ) o inclusive grabar el bootloader ( Herramientas/Grabar secuencia de inicio)

En la imagen podemos ver un ejemplo de Leonardo programando un Attiny45

lunes, 18 de agosto de 2014

Arduino atmega644p : Un arduino ampliado

En ocasiones los puertos disponibles en un Arduino basado en el atmega328 no son suficientes.

Tenemos varias opciones utilizando otros chips de Atmel: atmega1284p, atmega644p, atmega324p.

Mi experiencia con el atmega1284p no es muy buena, ya que hay chips con un defecto de fabricación que hace que la comunicación mediante el primer puerto serial (pines 14 y 15) sea muy difícil. Por lo visto es un problema de ruido que se genera al estar estos pines muy cerca de los pines del cristal. (Hay una versión experimental que utiliza el UART1 optiboot).

Sin embargo al utilizar el chip atmega644p los resultados son muy satisfactorios.

El procedimiento para "crear" un Arduino con un atmega644p es similar al utilizado con un atmega328:

Armar el hardware : Cristal externo de 16Mhz , interruptor para reset y led a un puerto para pruebas.
Grabar el bootloader mediante un Ardunino en modo ISP : Instructables.
Utilizar una interfase serial/USB para subir los programas.

En la imagen se muestra una versión en protoboard que incluye un regulador de 5V, un panel LCD de dos lineas, un célula fotoeléctrica y un termistor NIC. La lectura de los sensores se muestra en el LCD junto con el tiempo en segundos desde el inicio.

En el caso del bootloader hay varias opciones disponibles.

La primera que utilicé fué la versión de Sanguino . El problema con esta versión es que los puertos analógicos están mapeados de forma diferente al Arduino tradicional.
Otra opción es mighty-1284p haciendo varias modificaciones en el archivo boards.txt
La versión que utilicé fue la de leonardomiliani.com para el IDE 1.0.5

En el archivo comprimido de leonardomiliani.com se indican los problemas de conexión con los chips 1284p y 644p y las posibles soluciones. En mi caso , utilizando el 644p, pude subir programas conectando directamente los cables RX/TX a los pines del chip.

Al probar el comportamiento del chip con dieferentes programas pude comprobar que un programa de validación de libreria de punto flotante que en el Arduino con 386p se detenía en las pruebas de coseno, ahora finalizaba correctamente. Puede ser que la razón sea que en el 644p hay mas RAM disponible.

lunes, 7 de julio de 2014

Industrial Arduino : Arduino en ambientes industriales

El tema del uso de Arduino en ambientes industriales ha generado mucha literatura en la web. Un ejemplo de ello son los siguientes enlaces:

Las razones para la utilización de Arduino son costo y facilidad de desarrollo ( no olvidemos la gran cantidad de librerías existentes en la web)

Lo cierto es que se puede apreciar una gran resistencia al uso de Arduino en aplicaciones en ambientes industriales, sobre todo en áreas donde el tema de seguridad es muy importante.

Pienso que debe distinguirse entre el uso de las tarjetas tradicionales de Arduino y el uso de los microcontroladores de Atmel.

En relación a las tarjetas considero que en efecto, al no estar diseñadas para su utilización en ambientes industriales pues es lógico que no se recomiende su uso. Sin embargo hay tarjetas en el mercado que si están diseñadas bajo estas especificaciones:

El otro punto, mucho mas técnico, es el diseño como tal de los micros Atmel , específicamente los de 8 bits. Existen análisis donde se indica que ciertas características deseables para micros en ambiente industrial no se cumplen. Por ejemplo, si falla el cristal el micro no utiliza como respaldo el circuito RC interno. Es cierto, hay características que dotan de mayor robustez al micro en caso de fallas, pero por lo general estas "deficiencias" pueden ser cubiertas de otra forma. Sin lugar a dudas existirán casos muy específicos donde una o varias de estas características sean imprescindibles.

También existen ejemplos donde el Arduino se ha utilizado como sustituto de módulos obsoletos o de difícil reparación, tal es el caso del enlace Sustitución de controlador con Arduino

Adicionalmente existen desarrollos de software que permiten la integración de Arduino en ambientes industriales :

Este tema está abierto y considero que la utilización de Arduino en ambientes industriales debe ser analizada caso por caso, sin embargo, el tema seguridad es muy importante, y nunca puede tener mayor prioridad la economía que la seguridad.

domingo, 29 de junio de 2014

Simuladores Arduino

En algún foro leí una vez una solicitud de un visitante acerca de información de simuladores de Arduino. Uno de los miembros del foro le respondió que para que un simulador, con lo económico que resulta adquirir un Arduino. Ciertamente el argumento es válido, sin embargo, en ocasiones es útil tener a disposición un programa que permita emular/simular el funcionamiento del Arduino.

Existen varios emuladores/simuladores en el mercado , tanto gratuitos como de pago. Una lista reducida sería:

Simulator for Arduino : De pago aunque dispone de una versión gratis con ciertas restricciones.
Arduino Simulator for iPhone : De pago
Proteus : De pago
Virtual Breadboard : De pago
Emulare : Gratis. Emula microcontroladores ATMega
Simuino : Gratis. Solo para Linux
AVR Simulator : Después del período de evaluación debe adquirirse una licencia.
SimulIDE : Gratis
Arduino Debugger : Gratis. En el archivo que se descarga viene el fuente y el ejecutable para windows 64 bits.

En general las versiones de pago son muy completas, especialmente Proteus, en comparación con las versiones gratis, las cuales disponen de un número limitado de componentes.

En el caso de Emulare tiene la opción de emular comunicación serial, con lo que podemos simular en el emulador scripts que hagan uso del puerto serial , como por ejemplo el shell bitlash:

SimulIDE tiene una interfase gráfica muy amigable:

viernes, 20 de junio de 2014

Alimentación de Arduino

Las tarjetas Arduino pueden ser alimentadas de varias formas:

Mediante una fuente externa al conector cilíndrico. Las tensiones recomendadas son : mínimo 7 Voltios y máximo 12 voltios. En mi opinión la tensión ideal es 9 Voltios.
Mediante el conector USB. En este caso se suministra directamente al circuito 5 Voltios sin pasar por la etapa de regulación de tensión.
Mediante los pines VIN y GND : Es similar a la primera opción. No es recomendable.
Mediante los pines VCC y GND : Es similar a la segunda opción. Tampoco es recomendable

En principio las tarjetas permiten estar alimentadas al mismo tiempo por el conector cilíndrico y por el conector USB, dando preferencia a este último, sin embargo no es recomendable.

Cuando armamos un Arduino en un protoboard usualmente incorporamos un regulador de tensión de 5 Voltios para poder alimentar el circuito con una tensíón de entrada de entre 7 y 12 voltios (similar a la opción 1 mencionada anteriormente):

Aunque la etapa de regulación es sencilla (el regulador y tal vez dos condensadores), podemos alimentar directamente el circuito mediante tres o cuatro baterias AA/AAA. Esto es debido a que las especificaciones del micro atmega 386p establecen que puede operar a 16Mhz con una alimentación de 3.6 Voltios como mínimo.

En la imagen se muestra un circuito alimentado con tres baterias de NiCd recargables. La tensión suministrada es de aproximadamente 3.8 Voltios, siendo suficiente inclusive para alimentar un display de 7 segmentos.

A continuación los valores mínimos asociados a la frecuencia de operación:

4.5 Voltios para 20Mhz
3.6 Voltios para 16Mhz
2.7 Voltios para 10Mhz
1.8 Voltios para 8Mhz

No hay que olvidar que el valor máximo en cualquier caso no debe superar 5.5 Voltios.

lunes, 16 de junio de 2014

Comunicación serial con Arduino

En ocasiones requerimos visualizar información enviada por el Arduino a través de su puerto serial.

Hoy en día muy pocos computadores tienen puertos seriales, la tecnología vigente es el puerto USB, que también utiliza comunicación serial pero bajo otros parámetros técnicos.

Es por ello que se requiere una interfase entre el puerto serial del microcontrolador y el puerto USB del computador.

Tarjetas como la UNO, Leonardo, MEGA, etc , incorporan esta interfase. Por otro lado tarjetas como la PRO o mini no la incorporan, por lo que se requiere la utilización de interfases externas (ver la entrada Convertidores serial/USB ).

Esto en cuanto al hardware. Para poder visualizar la información que entra por el puerto USB del computador, debemos ejecutar un programa específico para dicho propósito. El IDE de Arduino incorpora el Monitor/Serial , el cual dispone de una línea para enviar comandos al Arduino y una ventana para mostrar la información enviada por éste.

El Monitor/Serial en general es suficiente para la mayoría de los usuarios y usos . Sin embargo, existen varias alternativas con ventajas/desventajas en relación con el primero.

Se puede consultar el artículo Serial Terminal Basics (inglés) de Sparkfun donde se explica en detalle este tema y se analizan las diferentes alternativas disponibles.

Es importante tener en cuenta que debe parametrizarse el programa que estemos utilizando para que la conexión con el Arduino funcione adecuadamente. Los parámetros mas importantes son:

Puerto COM a utilizar
Velocidad de conexión (baud)
Protocolo de conexión : Software
Formato de la data : 8 bits, sin paridad y 1 bit de stop

sábado, 14 de junio de 2014

Cargar programa compilado (hex) mediante AX Loader y XLoader

Un script en Arduino es un programa fuente en lenguaje de programación similar a C.

El script se crea en el IDE , se compila (se genera un archivo con extensión .hex) y se carga en el Arduino (al presionar el botón Cargar del IDE se compila y se carga en el micro).

En ocasiones no disponemos del programa fuente, sólo del programa ya compilado.

Si deseamos cargarlo en el Arduino no podemos hacerlo mediante el IDE, necesitamos utilizar otro tipo de aplicación diseñada para este propósito.

En realidad el programa que requerimos viene incorporado en el IDE y se llama avrdude.

Este programa no es gráfico, es un programa tipo linea de comando y su ejecución requiere suministrar una serie de parámetros algo complicados.

Para solventar este inconveniente se han desarrollado interfases gráficas que interactúan con el avrdude y su ejecución resulta muy sencilla.

Dos de estos GUI (interfase gráfica) que destacan por su sencillez son AX Loader y XLoader .

AX Loader:

Como se puede ver en la pantalla, requerimos suministrar el modelo de la tarjeta, el puerto y el nombre del archivo compilado (extensión .hex) .

Xloader:

En este caso requerimos suministrar el nombre del archivo compilado (extensión .hex) el modelo de la tarjeta , el puerto y la velocidad de comunicación. Este último parámetro lo asigna por defecto el programa al seleccionar la tarjeta.

Es importante tomar en cuenta que es necesario que el Arduino tenga pregrabado el bootloader, ya que estamos haciendo una conexión a través del puerto serial.

Si tenemos un Arduino "virgen" debemos grabar el bootloader mediante un programador, que puede ser otro Arduino actuando como programador ISP.

Actualización 24/02/2020 :

También están disponibles los programas AVRDDudess y AVRDDude GUI que son interfases gráficas (GUI) para el programa de comandos avrdude.

viernes, 13 de junio de 2014

Shells para Arduino

Una shell es algo parecido a un mini sistema operativo en modo caracter, en lugar del ambiente gráfico al que estamos acostumbrados en el ordenador.

Es decir , si conectamos un Arduino a un computador ejecutando un programa terminal/serial, podemos enviarle comandos que el Arduino ejecutará directamente.

Aunque no creo que sean de utilidad práctica, hay disponibles varios desarrollos, algunos de los cuales realmente son impresionantes (bitlash por ejemplo).

En la imagen podemos ver una sesión de bitlash. Se puede observar que hay tres procesos ejecutándose en multitarea !!! :

Listado parcial de shells:

bitslash
AVRSH
Sdfrethsh
arsh
CmdArduino (solo CR en terminal/serial)
fruitshell (solo NL en terminal/serial)

jueves, 12 de junio de 2014

Convertidores serial/USB

Las tarjetas del tipo Arduino UNO, Leonardo, Due,Fio, etc se conectan directamente al puerto USB del computador mediante una interfase incorporada en la tarjeta.

Por otro lado tarjetas como Arduino PRO, Mini, etc requieren una interfase externa para poder establecer dicha comunicación. Lo mismo ocurre si armamos una Aduino en protoboard.

En estos casos una posibilidad es utilizar interfases de conversión entre la comunicación serial del microcontrolador y la interfase USB del computador.

En el mercado existen una gran variedad de dichas interfases, basadas en diferentes integrados diseñados especialmente para este propósito (CP2102, FT232, PI-2303, etc).

Una primera característica que diferencia estas interfases es el número de pines de comunicación que incorporan.

Usualmente las mas económicas tiene cuatro pines , la función de los mismos sería:

+VCC : Usualmente +5 Voltios, pero también puede ser +3.3 Voltios
+GND : Tierra
TxD : Transmisión de data
RxD : Recepción de data

La conexión de estos pines con el Arduino es:

+VCC con conexión de alimentación VCC del Arduino
+GND con conexión de Tierra del Arduino
TxD con el puerto Dx del Arduino
RxD con el puerto Tx del Arduino

Si estamos trabajando con una tarjeta que ya tiene alimentación, solo requerimos conectar el pin +GND para establecer la referencia común de tierra.

En ocasiones hay que invertir las conexiones TxD y RxD (problema de nomenclatura de los fabricantes).

Una característica incómoda de estas tarjetas es que tenemos que inicializar el Arduino (reset) para que la carga del script sea exitosa. Cuando veamos que el mensaje en el IDE cambia de Compilar .. a Cargando , presionamos el boton de Reset durante unos 3-5 segundos. Lo mas importante es no esperar demasiado para presionar el Reset.

En el caso de interfases con seis pines tendríamos, además de los mencionados anteriormente, los siguientes:

En este caso la conexión con tarjetas Arduino (PRO,Mini,etc) está especificada en el portal arduino.cc .

Si estamos trabajando con un Arduino que hemos armado en protoboard debemos conectar el pin RTS mediante un condensador de 100nF al pin Reset del microcontrolador.
Con estas interfases la carga de scripts es automática, no necesitamos presionar el botón de Reset en el Arduino.

Es importante tener en cuenta que hay interfases de 6 pines donde el pin RTS no permite hacer el reset automático del Arduino, en este caso debemos utilizar el procedimiento para interfases con cuatro pines.

No hay que olvidar que deben instalarse los drivers correspondientes en el Computador para que éste reconozca la interfase. Usualmente en linux es automático. En el caso de windows es probable tener que hacer la instalación manualmente a partir de los archivos suministrados por el fabricante del integrado.

miércoles, 11 de junio de 2014

Números muy grandes en Arduino

Arduino es una plataforma orientada a conectar dispositivos analógicos o digitales a los puertos de entrada/salida , es decir es un "microcontrolador". Sin embargo no deja de ser un microprocesador. Y es por ello que podemos utilizarlo para casi cualquier tipo de aplicación capaz de ser ejecutada por un micro.

Y lo cierto es que hay gente muy creativa desarrollando aplicaciones no convencionales para esta plataforma.

Una de estas aplicaciones no convencionales es la librera BigNumber , una adaptación hecha por Nick Gammon de la libreria GNU bc (linux). Esta librería permite hacer operaciones con números muy grandes, del tipo que estudian los matemáticos en Teoría de Números.

Al ejecutar alguno de los ejemplos que incluye la librería no deja de sorprender la capacidad del Arduino para ejecutar estos cálculos tan complejos, no olvidemos que es un micro de 8 bits corriendo a 16Mhz, en comparación con los micros de 64 bits corriendo a varios Gigahertz que utilizamos en nuestros computadores.

En la imagen un ejemplo de cálculo de factoriales :

El script calcula los factoriales de los números enteros 1 al 200 . El cálculo no demora mas de 12 segundos !!!

La librería BigNumberMath complementa la anterior con varias funciones nuevas y corrección de otras ya existentes. Debe utilizarse la versión del enlace: version_sin_errores

Un experimento interesante de overclock en el Arduino es cambiar el cristal de 16MHz por otro de 24Mhz:

Se modifica el script para establecer una velocidad de comunicación serial de 38400 bauds ( Serial.begin (38400); ) .
Se carga el script en el Arduino.
Se desconecta la alimentación, cambiamos el cristal.
Conectamos el Arduino de nuevo y utilizamos el monitor serial a una velocidad de conexión de 57600 baud.
Inicializamos el Arduino

En el caso del script anterior el tiempo de ejecución baja a menos de 9 segundos.

lunes, 9 de junio de 2014

BASIC corriendo en Arduino

Aunque no creo que pueda ser de uso práctico, varios autores han hecho esfuerzos muy encomiables para lograr que interpretadores BASIC corran en forma nativa en la plataforma Arduino.

Me refiero a que mediante un programa de conexión serial en el PC al que está conectado el Arduino (similar al Monitor Serial del IDE de Arduino), podemos crear, guardar en el eeprom interno y ejecutar programas BASIC.

Parece ser que el punto de partida es el TinyBasic de Mike Field , basado en el TinyBasic original para el venerable CPU 68000 de Motorola (que días aquéllos !!!).

Una de las versiones es TinyBasic_plus de Scott Lawrence, que incluye nuevos comandos.

Es recomendable formatear la eeprom (EFORMAT) antes de guardar un programa por primera vez (ESAVE). Cuando se guarda un programa en eeprom, este se ejecuta al inicializar el Arduino.

En la imagen un Arduino armado en protoboard conectado a PC mediante interfase serial/USB y ejecutando TinyBasic_plus:

Otros desarrollos:

Nanode/TinyBasic
Arduino BASIC shield
Single chip AVR BASIC Computer
BASIC Pocket PC
Bitlash : No es BASIC, pero merece la pena hecharle un vistazo. (Antes de trabajar con un puerto debe definirse su modo de trabajo : pinmode(13,1) define el puerto 13 como salida).
AttoBasic : Interesante desarrollo a partir de NASCOM Tiny Basic . Es un interpretador que utiliza variables tipo byte. A pesar de las limitaciones que esto impone sus requerimientos de hardware son mínimos y corre hasta en el ATtiny2313.

domingo, 8 de junio de 2014

Termómetro digital minimalista con ATtiny 45

En la imagen se muestra el circuito de un termómetro digital minimalista realizado con un ATtiny 45:

Componentes:

ATtiny 45 utilizando reloj interno de 8Mhz
Sensor de temperatura TMP35
Tres leds : Rojo, amarillo y verde
Tres resistencias de 240 Ohm

El programa que se ejecuta lee la tensión del sensor y la convierte a grados centígrados.

Para mostar el valor de la temperatura se utilizan los tres leds:

El primero (de color rojo) parpadea una vez indicando que se va a mostrar el valor leído.
El segundo (de color amarillo) muestra las decenas y parpadea tantas veces como decenas de grados tenga el valor leído.
El tercero (de color verde) muestra las unidades y parpadea tantas veces como unidades tenga el valor leído.

Supongamos que la temperatura tiene una valor de 25°C , entonces el led rojo parpadea una vez, a continuación el red amarillo parpadea dos veces y por último el led verde parpadea cinco veces.

Para programar el ATtiny se utilizó un Arduino UNO en modo programador ISP y se hicieron las conexiones correspondientes con el ATtiny.

// tiny 45 minimalistic thermometer 
// using lm35 and internal analog reference

int sensorPin = 3;     
int ledPin0 = 0;   // New temp measure indicator
int ledPin1 = 1;   // Units
int ledPin2 = 2;   // Tens
int i;
int units;
int tens;
float sensorValue = 0;   
float tempC=0;

void setup() {   
  analogReference(INTERNAL);
  pinMode(ledPin0, OUTPUT);  
  pinMode(ledPin1, OUTPUT);  
  pinMode(ledPin2, OUTPUT);  
  pinMode(sensorPin, INPUT);   
}

void loop() {  
  sensorValue = analogRead(sensorPin);    
  tempC=(sensorValue*110.0)/1023.0;
  tens=tempC / 10;
  units= tempC - ( tens * 10 ) ;
  digitalWrite(ledPin0, HIGH);
  digitalWrite(ledPin1, LOW); 
  digitalWrite(ledPin2, LOW); 
  delay(1500);  
  digitalWrite(ledPin0, LOW);
  delay(500); 
  
  for (int i=1; i <= tens; i++) {
    digitalWrite(ledPin1, HIGH); 
    delay(500); 
    digitalWrite(ledPin1, LOW); 
    delay(500); 
  }  
  
   for (int i=1; i <= units; i++) {
    digitalWrite(ledPin2, HIGH); 
    delay(500); 
    digitalWrite(ledPin2, LOW); 
    delay(500); 
  }  
  
  delay(500);                  
}

sábado, 7 de junio de 2014

Termómetro digital con Arduino pro mini

En la imagen podemos apreciar un termómetro digital utilizando un Arduino pro mini.

Componentes:

Arduino pro mini
Mini protoboard de 170 puntos
Display rojo AC de 7 segmentos
Resistencia de 470 Ohms
Sensor de temperatura TMP35
Batería recargable de 9 Voltios

El programa que se ejecuta lee el valor en voltios del sensor, lo convierte en grados centígrados y muestra los dígitos uno a la vez en el display de 7 segmentos.

Para simplificar el circuito se utilizó una resistencia de 470 Ohms entre el ánodo y tierra.

viernes, 6 de junio de 2014

Control de acceso RFID

En la imágen se muestra un circuito que permite gestionar el control de acceso mediante tarjetas RFID de 125Khz :

Componentes:

Arduino Leonardo
Lector RFID ID-12
DS1307 Real Time Clock
Memoria serial 24AA256
Rele reed
Buzzer
Led bicolor
Led azul de lectura
Led amarillo de acceso

El programa que se ejecuta incluye un menú en la pantalla serial con las siguientes funciones:

Registro de Tarjetas
Eliminación de Tarjetas
Listar Tarjetas registradas
Listar histórico de accesos
Eliminar histórico de accesos
Configuración de Fecha y Hora

Cada vez que una tarjeta se presenta al lector se registra el intento de acceso. Si la tarjeta está registrada el led bicolor emite el color verde , el buzzer genera un tono de aprobación y el relé reed se activa encendiendo el led de acceso. Si la tarjeta no está registrada el led bicolor emite el color rojo y el buzzer genera un tono de rechazo.

Páginas

domingo, 5 de octubre de 2014

sábado, 27 de septiembre de 2014

domingo, 21 de septiembre de 2014

domingo, 14 de septiembre de 2014

jueves, 11 de septiembre de 2014

sábado, 30 de agosto de 2014

sábado, 23 de agosto de 2014

lunes, 18 de agosto de 2014

lunes, 7 de julio de 2014

domingo, 29 de junio de 2014

viernes, 20 de junio de 2014

lunes, 16 de junio de 2014

sábado, 14 de junio de 2014

viernes, 13 de junio de 2014

jueves, 12 de junio de 2014

miércoles, 11 de junio de 2014

lunes, 9 de junio de 2014

domingo, 8 de junio de 2014

sábado, 7 de junio de 2014

viernes, 6 de junio de 2014