Vistas de página en total

jueves, 22 de septiembre de 2011

Comparación de microcontroladores:

AVR de Atmel:

Los AVR son una familia de microcontroladores RISC de Atmel. El AVR es una CPU de arquitectura Harvard. Tiene 32 registros de 8 bits.
El AVR fue diseñado desde un comienzo para la ejecución eficiente de código C compilado. Como este lenguaje utiliza profusamente punteros para el manejo de variables en memoria, los tres últimos pares de registros internos del procesador son usados como punteros de 16 bit al espacio de memoria externa, bajo los nombres X, Y y Z.

Distintos tipos de microcontroladores:

-8bits TinyAVR ( es muy pequeño en memoria y cantidad de pines)
-8bits megaAVR (es un microcontrolador grande en memoria y cantidad de pines)
-8/16bits (es un microcontrolador muy grande en memoria y cantidad de pines)
-32bits AVR UC3 ( es un microcontrolador muy potente)
-microcontroladores para manejo de baterias ( para usos especiales)
-microcontroladores para la industria automotriz ( para usos especiales tambien)

Los AVR son microcontroladores rapidos , ya que no dividen la frecuencia del timer , y ademas favorecen al ahorro de energía. Su desventaja es que son muy dificiles de conseguir en argentina.

Tomemos como ejemplo el microcontrolador ATmega8 , ya que es el mas característico , asi como el 16F84 para microchip , o el GP32 para Freescale.

Caracteristicas:

-Arquitectura RISC avanzada
 130 intrucciones ; 1 por cada ciclo de clock.
 32x8 registros de propósito general
 Hasta 16 MIPS(millones de instrucciones por segundo) a 16MHz
-8 Kb de memoria Flash
-0,5 Kb de memoria EEPROM
-1 Kb de memoria RAM
-23 pines de entrada/salida
-18 interrupciones (2 en pines de entrada/salida)
-3 puertos 
-Arquitectura Harvard
-40 mA como máximo por pin , en modo source y sink
-300mA como máximo entre la suma de todos los bancos
-No posee arquitectura completamente ortogonal
-No posee banco
-6V como tensión máxima que puede soportar

Periféricos ATmega8:

-2 temporizadores /contadores de 8 bits con pre-escala y un modo de comparación
-1 temporizador / contador de 16 bits con pre-escala y un modo de comparacion y de captura
-RTC(real time counter)
-3 canales PWM
-ADC de 8 canales (TQFP y QFN/MLF) con los bits de precision
-ADC de 6 canales (PDIP) con los bits de precisión.
-TWI (two - wire interfae) (tambien conocido como I2C)
-Ustart

-Power on Reset y Brown-out
-Oscilador RC interno calibrado
-Interrupciones internas y externas 
-Bits de seguridad /bloqueo
-Modos de ahorro de energía

Herramientas de programación:

-Programadores
            AVRDUDE
PONYPROGE
-Compiladores
GNUToolChain
Siml-ación:
SimulAVR + GDB
Entornos Gráficos
Code::Bocks
Eclipse Plugin AVR


Cuando se genera un archivo con el compilador , en esta marca se llama .elf


Freescale (antiguamente MOTOROLA):
Tomemos como ejemplo el microcontrolador GP32 , que es uno de los mas comunes y mas "fáciles" de conseguir. ( estos microcontroladores son difíciles de conseguir en nuestro país):


-Características:
100 Veces más rápido
Fácil programación
Es de 8/16Bits
Posibilidad de multiplicar y dividir ( en los de otras empresas esto no es posible
Se comunica fácilmente con otros microcontroladores
Funciona entre -40°C  a 85°C
Posee 512Mb de memoria RAM
Posee memoria EEPROM de 32K
Modo Stand-By
Tiene puerto SERIE
Tiene una memoria sin bancos
Arquitectura Von Neumann
Memoria de Datos y Memoria de Programa en el mismo lugar (lo que provoca que el Bus no pueda mandar un código e ir buscando otro al mismo tiempo).
Memoria Flash: 32K
Divide por 4 la frecuencia del oscilador
15mA como corriente máxima en modo sink y source
Cuando se genera un archivo resultante con el compilador este sera .S19

Estas son algunas de las diferencias del código de freescale;

$ = numero hexadecimal
% = numero binario
# = el numero que le sigue se toma como una posición de memoria
#[ = escribir un literal
mov      #{ XXXXXXX} , Y ( lo que esta entre llaves lo pone en 1 . Lo que esta despues de la coma , es de que registro lo extrae
* = a continuación se escribira un comentario
1 = salida
0 = entrada
mov    #$23 , T1MODL ( en este caso primero se marca lo que voy a mover , y luego donde)
Cuando al final del numero hay una T, quiere decir que esta en base decimal

Con estos microcontroladores , no es necesario programar directamente el microcontrolador , si no que podemos programar el butloader , que significa que el micro esta siendo programado , mientras esta siendo utilizado.
Posee un Timer : Cuando el contador que tiene , llega a los ciclos que configuramos , se produce la interrupción que hayamos determinado. Esto es causa del desborde que se produce ( se produce un flag (es un bit dentro de un registro que automáticamente se pone en 1) , y llama a la subrutina). Los pulsos provienen del clock.
La ventaja de los programas de Freescale es que no necesitamos un delay para realizar instrucciones en el programa principal

jueves, 15 de septiembre de 2011

Act 5: Contador - Sistemas secuenciales (Parte B)

Circuito esquemático :

Circuito de contador en PCB:


 Programa en C para el contador en el PIC12F683



#include <main.h>



void main()
{

   setup_adc_ports(NO_ANALOGS|VSS_VDD);
   setup_adc(ADC_CLOCK_DIV_2);
   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
   setup_timer_1(T1_DISABLED);
   setup_timer_2(T2_DISABLED,0,1);
   setup_comparator(NC_NC);
   setup_vref(FALSE);
   setup_oscillator(OSC_8MHZ);

   while(!input(PIN_A3));

  

output_a (0b011001);
delay_ms (1000);
output_a (0b011000);
delay_ms (1000);
output_a (0b001111);
delay_ms (1000);
output_a (0b001110);
delay_ms (1000);
output_a (0b001101);
delay_ms (1000);
output_a (0b001100);
delay_ms (1000);
output_a (0b001011);
delay_ms (1000);
output_a (0b001010);
delay_ms (1000);
output_a (0b001001);
delay_ms (1000);
output_a (0b101000);
}


Otra forma de realizar el mismo programa , pero con vectores es :

#include <main.h>


void main()
{
   int secuencia[] = {0b011001, 0b011000, 0b001111, 0b001110,
                   0b001101, 0b001100, 0b001011, 0b001010,
                   0b001001, 0b101000};
   
   int i;

   setup_adc_ports(NO_ANALOGS|VSS_VDD);
   setup_adc(ADC_CLOCK_DIV_2);
   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
   setup_timer_1(T1_DISABLED);
   setup_timer_2(T2_DISABLED,0,1);
   setup_comparator(NC_NC);
   setup_vref(FALSE);
   setup_oscillator(OSC_8MHZ);


   while(!input(PIN_A3));

   for (i=0; i < 10; i++) {
      output_a (secuencia[i]);
      delay_ms (1000);
   }
}

Foto del circuito en el protoboard:

Video del programa para comprobar que funciona en el Proteus.



miércoles, 14 de septiembre de 2011

Hola Mundo!

;====================================================================
; Programa principal
;====================================================================
Main
call LCD_Inicializa
call Retardo_1ms
movlw 'H'
call LCD_Caracter
movlw 'o'
call LCD_Caracter
movlw 'l'
call LCD_Caracter
movlw 'a'
call LCD_Caracter
movlw ' '
call LCD_Caracter
movlw 'M'
call LCD_Caracter
movlw 'u'
call LCD_Caracter
movlw 'n'
call LCD_Caracter
movlw 'd'
call LCD_Caracter
movlw 'o'
call LCD_Caracter
movlw '!'
call LCD_Caracter
goto $
;==================================================================== 
END ;Directiva que indica la finalización del pgm
Aclaración:
En la libreria LCD_4BIT.INC , modificamos en la parte de Subrutina "LCD_Inicializa" lo siguiente : 
(Esto se realizó para no tener problemas con la frecuencia del LCD y estar modificando la frecuencia del microcontrolador):



; Subrutina "LCD_Inicializa" ------------------------------------------------------------
;
; Inicialización del módulo LCD: Configura funciones del LCD, produce reset por software,
; borra memoria y enciende pantalla. El fabricante especifica que para garantizar la
; configuración inicial hay que hacerla como sigue:
;
LCD_Inicializa
bsf STATUS,RP0 ; Configura las líneas conectadas al pines RS,
bcf LCD_PinRS ; R/W y E.
bcf LCD_PinEnable
bcf LCD_PinRW
bcf STATUS,RP0
bcf LCD_PinRW ; En caso de que esté conectado le indica
; que se va a escribir en el LCD.
bcf LCD_PinEnable ; Impide funcionamiento del LCD poniendo E=0.
bcf LCD_PinRS ; Activa el Modo Comando poniendo RS=0.
call Retardo_20ms
movlw b'00110000'
call LCD_EscribeLCD ; Escribe el dato en el LCD.
call Retardo_5ms
movlw b'00110000'
call LCD_EscribeLCD
call Retardo_200micros
movlw b'00110000'
call LCD_EscribeLCD
call Retardo_20micros ; NUEVO
movlw b'00100000' ; Interface de 4 bits.
call Retardo_20micros ; NUEVO
call LCD_EscribeLCD



La parte señalada en amarillo es la que fue agregada a esta subrutina.