General packet radio service

View more presentations from Percy Julio Chambi Pacco

Teclado Matricial 4x4

Es un dispositivo de entrada que consiste en un arreglo matricial de 16 teclas (pulsadores). Dispone de un conector SIL (Single In Line) de 8 pines: 4 filas y 4 columnas. La interconexión de los pulsadores es como se muestra en la imagen:

Cuando se presiona una tecla se conecta una fila con una columna. La manera de averiguar la tecla presionada consiste en enviar un nivel lógico a una de las filas (diferente al nivel de las filas restantes) y buscar la columna por la que se recibe el mismo nivel lógico. De esta manera se obtiene la fila y columna al igual que en una matriz. 

El diagrama de conexión típico al ATmega8 es el siguiente:

Las resistencias de 1K son necesarias para evitar hacer un cortocircuito accidental si se comparten los mismos pines del PIC con otro periférico, como por ejemplo un Display o un LCD.

Las resistencias de 10K son necesarias para asegurar el nivel lógico 0 en las entradas del ATmega8.

Algoritmo de búsqueda:

• Los pines PD0-PD3 se configuran como Salidas. Los pines PD4-PD7 se configuran como Entradas.

• Las filas del teclado se conectan a los pines PD0-PD3 y las columnas a los pines PD4-PD7.

• Se envía “0” a todas las filas.

• Se envía “1” a la primera fila.

• Se verifica el nivel lógico en cada una de las columnas. Si se pulsó una tecla de la primera fila se obtendrá un “1” en la columna correspondiente.

• Si no se encuentra un “1” (no se pulsó tecla en la primera fila) se envía un  “1” a la siguiente fila (a las filas restantes se envía “0”).

• Se verifican las columnas en busca del nivel lógico “1”.

• El procedimiento continúa hasta completar las 4 filas.

• Conociendo la fila por la que se envió “1” y conociendo la columna por la que se recibe “1” se puede conocer la tecla pulsada.

 Programa Para ATmega8:

El programa lee la tecla pulsada en un teclado matricial 4x4 y simultáneamente muestra la última tecla pulsada en un display de 7 segmentos.

Diagrama de Conexión:

Programa en Assembler:

;---------------------------------------------------------
;Autor: LONELY113
; http://lonely113.blogspot.com
;
;Programa para control de teclado matricial 4x4 
;Adicionalmente muestra la tecla pulsada en un display
;Para teclado: Salida: PD0-PD3
;        Entradas: PD4-PD7
;Para Display: Salidas: PD1-PD7 (7 segmentos)
;        PC0 (Habilitacion catodo comun)
;Oscilador interno de 8 MHz
;---------------------------------------------------------
.nolist
.include "m8def.inc"
.list
.device  atmega8

.def KEY=r17
.def TEMP=r18
.def COUNT=r19
.def CHAR=r20
.def ROW=r21

.org 0x0000

; Inicializacion de stack

 ldi r16,HIGH(RAMEND)
 out SPH,r16
 ldi r16,LOW(RAMEND)
 out SPL,r16

; Fin inicializacion de Stack

; Inicio de programa

 ldi r16,0x01
 out DDRC,r16  ; PC0 como salida
 ldi r16,0x0F
 out DDRD,r16  ; PD7-PD4 como entradas, PD3-PD0 como salidas
 sbi PORTC,0
 clr TEMP
BEGIN: clr KEY
 inc KEY
 ldi ROW,0x01
 out PORTD,ROW
KEY_V: nop
 sbic PIND,4         ; Verifica tecla pulsada en columna 1
 rjmp CON2  ; Ir a CON2 si se pulsa tecla
 inc KEY  ; Incrementar KEY si no se pulsa tecla
 sbic PIND,5  ; Verifica tecla pulsada en columna 2
 rjmp CON2  ; Ir a CON2 si se pulsa tecla
 inc KEY  ; Incrementar KEY si no se pulsa tecla
 sbic PIND,6  ; Verifica tecla pulsada en columna 3
 rjmp CON2  ; Ir a CON2 si se pulsa tecla
 inc KEY  ; Incrementar KEY si no se pulsa tecla
 sbic PIND,7  ; Verifica tecla pulsada en columna 4
 rjmp CON2  ; Ir a CON2 si se pulsa tecla
 inc KEY  ; Incrementar KEY si no se pulsa tecla
 cpi KEY,0x11
 brbs 1,CON1  ; Comprueba si llego a ultima tecla
 lsl ROW
 out PORTD,ROW
 rjmp KEY_V
CON1: clr KEY
 rjmp DISP
CON2: mov TEMP,KEY ; Retiene ultima tecla pulsada
DISP: ldi r16,0xFF
 out DDRD,r16 ; PORTD como salida
 rcall CONV
 out PORTD,CHAR
 cbi PORTC,0
 nop
 sbi PORTC,0
 ldi r16,0x0F
 out DDRD,r16 ; PD7-PD4 como entradas, PD3-PD0 como salidas
 clr r16
 out PORTD,r16
 out PIND,r16
 rjmp BEGIN

; Subrutinas

CONV: ldi ZH,HIGH(2*TABLE)
 ldi ZL,LOW(2*TABLE)
 add ZL,TEMP
 lpm
 mov CHAR,r0
 ret

; Tabla de datos

TABLE:
.DB 0x00,0x0C,0xB6,0x9E,0xE2,0xCC,0xDA,0xFA,0xF2,0x0E,0xFE,0xDE,0xBC,0xEE,0x7E,0xF8,0x72

Archivos de Programa:

Descargar

Multiplexaje de Display con Desplazamiento de Caracteres

Programa para ATmega8

El programa consiste en mostrar una serie caracteres en 4 display multiplexados.
los caracteres se muestran en grupos de 4 y se desplazan a la izquierda.

Diagrama de Conexión:

 
Funcionamiento:

• Aplicando un procedimiento de multiplexaje se muestran los primeros 4 caraceres (CHAR1, CHAR2, CHAR3 y CHAR4). 

• transcurrido un tiempo tal que el ojo pueda captar los caracteres se desplaza la cadena hacia la izquierda y se muestran los siguientes 4 caracteres (CHAR2, CHAR3, CHAR4, CHAR5). 

• El programa comprueba si se mostraron todos los caracteres y cuando esto ocurre el proceso se repite.

Programa en Assembler:

;-----------------------------------------------------------
;Autor: LONELY113
;  http://lonely113.blogspot.com
;
;Programa para multiplexar 4 display
;Muestra mensaje LONELY113 con desplazamiento a la izquierda
;Salidas: Puerto D (PD1-PD7) 7 segmentos de display
;   Puerto A (PB0-PB3) habilitacion de display 
;Tipo de display: Catodo comun
;Calibrado para oscilador interno de 8 MHz
;-----------------------------------------------------------
.nolist
.include "m8def.inc"
.list
.device  atmega8

.def CHAR=r1
.def COUNT1=r20
.def COUNT2=r21
.def COUNT3=r22
.def TEMP=r18

.org 0x0000

;Inicializacion de Stack
 ldi r16,HIGH(RAMEND)
 out SPH,r16
 ldi r16,LOW(RAMEND)
 out SPL,r16
; Fin inicializacion de Stack

; Inicio de programa

 ldi r16,0xFF
 out DDRB,r16  ;PORTB como salida de habilitacion
 ldi r16,0xFF
 out DDRD,r16  ;PORTD como salida a displays
 ldi r16,0x0F
 out PORTB,r16 ;Deshabilitacion de displays
 clr r16
 out PORTD,r16
 clr CHAR
 ldi COUNT1,0xFF ; Inicia contadores
 ldi COUNT2,0x20
 ldi COUNT3,0x10
BEGIN: rcall CONVER
 out PORTD,TEMP
 cbi PORTB,3
 nop   ; Habilita display 4
 sbi PORTB,3
 inc CHAR
 rcall CONVER
 out PORTD,TEMP
 cbi PORTB,2
 nop   ; Habilita display 3
 sbi PORTB,2
 inc CHAR
 rcall CONVER
 out PORTD,TEMP
 cbi PORTB,1
 nop                ; Habilita display 2
 sbi PORTB,1
 inc CHAR
 rcall CONVER
 out PORTD,TEMP
 cbi PORTB,0
 nop   ; Habilita display 1
 sbi PORTB,0
 ldi r16,0x03
 sub CHAR,r16 
 dec COUNT1  ; Rutina de repeticion de 
 brne BEGIN  ; visualizacion de los 
 ldi COUNT1,0xFF ; 4 caracteres
 dec COUNT2
 brne BEGIN
 ldi COUNT1,0xFF
 ldi COUNT2,0x20
 dec COUNT3
 brne BEGIN
 ldi COUNT1,0xFF     ; Reinicia contadores
 ldi COUNT2,0x20
 ldi COUNT3,0x10
 inc CHAR         ; 4 siguientes caracteres
 ldi r16,0x0D
 cp r16,CHAR
 brne BEGIN
 clr CHAR
 rjmp BEGIN

; Subrutinas

CONVER: ldi ZH,HIGH(2*TABLE)
 ldi ZL,LOW(2*TABLE)
 add ZL,CHAR
 lpm
 mov TEMP,r0
 ret

TABLE:
.DB 0x00,0x00,0x00,0x70,0x7E,0x6E,0xF3,0x70
.DB 0xDC,0x0C,0x0C,0x9E,0x00,0x00,0x00,0x00

Archivos de Programa:
Descargar

Multiplexaje de Display

Programa para ATmega8

El programa consiste en controlar la visualización simultánea en 4 display cátodo común de 7 segmentos utilizando el método de multiplexaje para optimizar el uso de pines del ATmega8 .

Diagrama de Conexión:

Funcionamiento:

• Se deshabilitan todos los displays (PB3-PB0=1111).

• Se envía dato a mostrar al Puerto D (PD1-PD7).

• Se habilita el display que mostrará el dato (Por ejemplo Display 1 a PB0=0).

• Se deshabilita Display (Por ejemplo Display 1 a PB0=1).

•  Se envía nuevo dato al Puerto D.

• Se habilita el display que mostrará el dato.

• Se deshabilita el display.

• El procedimiento continúa hasta enviar 4 datos a los 4 displays.

• Todo el proceso se repite endefinidamente. El ojo humano no llega a notar el parpadeo de los displays pues ocurre a muy alta frecuencia, por lo tanto se percibe como si los 4 displays estuvieran iluminados y mostrando los 4 datos simultáneamente.

• El diagrama siguiente muestra el funcionamiento:

Programa en Assembler:

;-------------------------------------------------------
;Autor: LONELY113
; http://lonely113.blogspot.com
;
;Programa para multiplexar 4 display 
;y mostrar el mensaje HOLA
;Salidas: Puerto D (PD1-PD7) 7 segmentos de display
;   Puerto B (PB0-PB3) habilitacion de display 
;Tipo de display: Catodo comun
;Oscilador interno de 8 MHz
;-------------------------------------------------------
.nolist
.include "m8def.inc"
.list
.device  atmega8

.def TEMP=r17
.def DISP=r18

.org 0x0000
; Inicializacion de Stack
 ldi r16,HIGH(RAMEND)
 out SPH,r16
 ldi r16, LOW(RAMEND)
 out SPL,r16
; Fin inicializacion de Stack

; Inicio de programa
  
 ldi r16,0x0F  ; PORTB habilitacion de displays
 out DDRB,r16  ; PB3-PB0
 ldi r16,0xFF 
 out DDRD,r16  ; PORTB salida a displays
 ldi r16,0x0F
 out PORTB,r16 ; Deshabilita displays
BEGIN: ldi DISP,0x00
 rcall CONVER
 out PORTD,TEMP
 cbi PORTB,3
 nop
 sbi PORTB,3
 inc DISP
 rcall CONVER
 out PORTD,TEMP
 cbi PORTB,2
 nop
 sbi PORTB,2
 inc DISP
 rcall CONVER
 out PORTD,TEMP
 cbi PORTB,1
 nop
 sbi PORTB,1
 inc DISP
 rcall CONVER
 out PORTD,TEMP
 cbi PORTB,0
 nop
 sbi PORTB,0
 rjmp BEGIN

; subrutinas

CONVER: ldi ZH,HIGH(TABLE*2)
 ldi ZL,LOW(TABLE*2)
 add ZL,DISP
 lpm
 mov TEMP,r0
 ret

; Tabla en memoria de programa
TABLE:
.DB 0xEC,0x7E,0x70,0xEE

Archivos de programa:
Descargar

Semáforo

Programa para ATmega8

Control de 2 semáforos.

-Uso de contadores
-Subrutina de retardo calibrado a 1 s para oscilador interno de 8 MHz

Diagrama de conexión:

Funcionamiento:

             La luz Verde dura 25 segundos.

             La Luz Ámbar dura 5 segundos.

             La Luz Roja dura 30 segundos.

• Se crea una variable TIME que se incrementa cada 1 segundo (calibrado mediante contadores para un cristal de 10 MHz).

• Se verifica la variable TIME para cambiar el estado de las luces según el siguiente diagrama:

Programa en Assembler:

;---------------------------------------------------------
;Autor: LONELY113
; http://lonely113.blogspot.com
;
;Programa de control de 2 semaforos 
;Salidas: Puerto D (RD0-RD5)
;    RD0=Verde1, RD1=Ambar1, RD2=Rojo1
;   RD3=Verde2, RD4=Ambar2, RD5=Rojo2
;Para reloj interno de 8 MHz
;---------------------------------------------------------

.nolist
.include "m8def.inc"
.list
.device  atmega8

.def COUNT1=r20
.def COUNT2=r21
.def COUNT3=r22
.def TIME=r4
.def STATE=r17

.org 0x0000

; Inicializacion de Stack
 ldi r16,LOW(RAMEND)
 out SPL,r16
 ldi r16,HIGH(RAMEND)
 out SPH,r16
; Fin inicializacion de Stack

; Inicio de programa

 ldi r16,0xFF
 out DDRD,r16 ; Puerto B como salida
 clr TIME
BEGIN: ldi r16,0x00 ; 00 segundos
 cp r16,TIME
 brbs 1,FIRST
 ldi r16,0x19 ; 25 segundos
 cp r16,TIME
 brbs 1,SECOND
 ldi r16,0x1E ; 30 segundos
 cp r16,TIME
 brbs 1,THIRD
 ldi r16,0x37 ; 55 segundos
 cp r16,TIME
 brbs 1,FOURTH
 rjmp FINISH
FIRST: ldi STATE,0x21 ; '00100001'b
 out PORTD,STATE
 rjmp FINISH
SECOND: ldi STATE,0x22 ; '00100010'b
 out PORTD,STATE
 rjmp FINISH
THIRD: ldi STATE,0x0C ; '00001100'b
 out PORTD,STATE
 rjmp FINISH 
FOURTH: ldi STATE,0x14 ; '00010100'b
 out PORTD,STATE
FINISH: nop
 rcall DELAY
 rjmp BEGIN

; Subrutinas

DELAY: ldi COUNT1,0xFF ; Retardo de 1 segundo
 ldi COUNT2,0xFF
 ldi COUNT3,0x29
LOOP: dec COUNT1
 brne LOOP
 ldi COUNT1,0xFF
 dec COUNT2
 brne LOOP
 ldi COUNT1,0xFF
 ldi COUNT2,0xFF
 dec COUNT3
 brne LOOP
 inc TIME
 ldi r16,0x3C ; reiniciar en 60 segundos
 cp r16,TIME
 brne RETURN
 clr  TIME
RETURN: ret

Archivos de programa:
Descargar

Selección de Código Binario y Visualización

Programa para ATmega8

Monitorea la entrada de un código binario (4 bits) y muestra la selección en decimal mediante un display.

-Aplicación de Tabla de datos para conversión Hexadecimal a 7 segmentos

Diagrama de conexión:

Programa en Assembler:

;---------------------------------------------------------
;Autor: LONELY113
; http://lonely113.blogspot.com
;
;Programa que muestra codigo seleccionado en binario
;en un display catodo comun de 7 segmentos
;Entradas: Puerto B (Pines PB0-PB3)
;Salidas: Puerto D (Pines PD1-PD7)
;Oscilador interno de 8 MHz
;---------------------------------------------------------
.nolist
.include "m8def.inc"
.list
.device  atmega8

.org 0x0000

;Definicion de stack
 ldi  r25,HIGH(RAMEND)
 out  SPH,r25
 ldi  r25,LOW(RAMEND)
 out  SPL,r25
;fin definicion de stack

BEGIN: ldi r18,0x00 ;RB7-RB0 como entradas
 out DDRB,r18 
 ldi r18,0xFF ;RD7-RD0 como salidas
 out DDRD,r18
LOOP: in r17,PINB
 andi r17,0x0F
 rcall SAVE
 out PORTD,r16
 rjmp LOOP

;Subrutinas

SAVE: ldi ZH,HIGH(2*TABLA)
 ldi ZL,LOW(2*TABLA)
 add ZL,r17
 lpm
 mov r16,r0
 ret

;Tabla de conversion hex a 7 segmentos
TABLA:
.DB 0x7E,0x0C,0xB6,0x9E,0xCC,0xDA,0xFA,0x0E 
.DB 0xFE,0xDE,0xEE,0xF8,0x72,0xBC,0xF2,0xE2
;Fin de tabla

Archivos de Programa:
Descargar

Luz Secuencial

Programa para ATmega8

Desplaza una luz en el Puerto B de derecha a izquierda y de izquierda a derecha.

-Comandos de rotación LSL y LSR
-Subrutina de retardo
-Calibrado para cristal interno de 8 MHZ

Esquema de conexión:

 Programa en Assembler:

;-----------------------------------------------------------
;Autor: LONELY113
;  http://lonely113.blogspot.com
;
;Programa para desplazamiento de luz en el puerto B

;Desplazamiento cada 1 s (Para oscilador interno de 8 MHz). 
;Salidas: Puerto B (PB0-PB7)
;-----------------------------------------------------------

;Para reloj interno de 8 MHz
.nolist
.include    "m8def.inc"
.list
.device     atmega8
.org     0x0000

.def COUNT1=r20
.def COUNT2=r21
.def COUNT3=r22
.def NUMBER=r4
.def TEMP=r17
; Inicializacion de stack
 ldi r16,LOW(RAMEND)
 out SPL,r16
 ldi r16,HIGH(RAMEND)
 out SPH,r16
; Fin inicializacion de stack

; Inicio de programa
 ldi r16,0xFF   ; Puerto B como salida
 out DDRB,r16
 clr r16   
 out PORTB,r16  ; Borrar PORTB 
 ldi r16,0x07 
 mov NUMBER,r16 ; Desplazar 7 posiciones
 ldi TEMP,0x01  ; '00000001'b
 out PORTB,TEMP  
FIRST: rcall DELAY
 lsl TEMP
 out PORTB,TEMP
 dec NUMBER
 brne FIRST    ; Desplaza 7 veces a la izquierda
 ldi r16,0x07
 mov NUMBER,r16
SECOND: rcall DELAY
 lsr TEMP
 out PORTB,TEMP
 dec NUMBER
 brne SECOND    ; Desplaza 7 veces a la derecha
 ldi r16,0x07
 mov NUMBER,r16
 rjmp FIRST    ; Bucle infinito

; Subrutinas

DELAY: ldi COUNT1,0xFF ; Retardo de 1 segundo
 ldi COUNT2,0xFF
 ldi COUNT3,0x29
LOOP: dec COUNT1
 brne LOOP
 ldi COUNT1,0xFF
 dec COUNT2
 brne LOOP
 ldi COUNT1,0xFF
 ldi COUNT2,0xFF
 dec COUNT3
 brne LOOP
 ret

Archivos de programa:
Descargar

Inversor Señal Sinusoidal

Este proyecto consiste en obtener una señal sinusoidal a partir de un voltaje DC bipolar.
El funcionamiento se fundamenta en una modulación SPWM que se obtiene mediante un microcontrolador.


ETAPAS

Circuito de control:

El circuito de control se implementa con un microcontrolador ATmega8. Genera dos señales SPWM desfasadas como se muestra en la figura. El programa está ajustado para que la señal sinusoidal de salida sea de 60 Hz.


Circuito de Aislamiento Control - Potencia:

Se utilizan dos optoacopladores 4N35 en la configuración que se muestra en la imagen. Notar que se requieren dos fuentes DC adicionales de 5V con tierras separadas (Señales de control independientes) Se puede obtener mediante un transformador de múltiples salidas, rectificadores y filtros.


Circuito de Potencia:

Se utilizan transistores NMOS como conmutadores de alta potencia. Se puede utilizar tiembién IGBT. También se requiere un filtro pasabajos con frecuencia de corte mayor a 60 Hz. No se requiere que sea de alta pendiente, pues la mosulación utilizada, SPWM, hace que los armónicos se encuentren muy alejados de la frecuencia fundamental.


Fuente Bipolar:

Como se observa en el circuito anterior, se requiere una fuente bipolar del voltaje deseado, en este caso 145 V. Se puede utilizar un tranformador o se puede tomar directamente de la red con el circuito que se muestra a continuación:

Funcionamiento

Modulación PWM


Señales de control


Señal de salida sin filtro


Señal de salida filtrada


Programa en Basic

$regfile = "m8def.dat"          'Microcontrolador ATmega8

$crystal = 8000000              'Reloj 8 MHz

$hwstack = 32                   'Hardware Stack

$swstack = 10                   'Software Stack

Config Portb = Output           'Puerto B como salida



'Configuración del módulo PWM

Config Timer1 = Pwm , Pwm = 10 , Compare A Pwm = Clear Down , Compare B Pwm = Clear Down , Prescale = 1



'Variables

Dim T As Single                  'Tiempo

Dim D As Single                  

Dim Duty As Word                 'Duty cycle (Word)



'Inicio de programa



T = 0                            'Reinicialización de variables



Loop1:                           'Bucle infinito

Do

 If T < 0.00833 Then             'Para semiciclo positivo

  D = T * 376.992                'Tiempo a radianes

  D = Sin(d)                     'Valor senoidal entre 0 - 1

  Duty = D * 1023

   Pwm1a = Duty                  'señal PWM1 con Duty Cycle  calculado

   Pwm1b = 0                     'Señal PWM2=0

  T = T + 0.0006                 'Incrementar T1 en 0.6 ms

 Elseif T < 0.01666 Then         'Para el semiciclo negativo

  D = T * 376.992                'Tiempo a radianes

  D = Sin(d)                     'Valor senoidal entre 0 - 1

  D = D * -1

  Duty = D * 1023

   Pwm1a = 0                     'Señal PWM1=0

   Pwm1b = Duty                  'Señal PWM2 con duty cicle calculado

  T = T + 0.0006                 'Incrementar T en 0.6 ms

 Else                            'reiniciar si se completaron los dos ciclos

  T = 0

 End If

Loop

End

Descargar

Arreglo de SCR como Triac

El siguiente proyecto consiste en implementar el funcionamiento de un Triac mediante 2 SCR con la finaliadad de poder manejar mayor potencia de la que permiten los Triac.

ETAPAS

Circuito de Control:

Para el disparo de los Triac se utiliza el microntrolador Atmega8 programado en lenguaje Basic. Para introducir el ángulo de disparo deseado se utiliza un portenciómetro conectado a un ADC. El ángulo de disparo va de 0º a 180º correspondiente a un semiciclo. El otro semicilo es simétrico.


Detector de Cruce por Cero:

Se utiliza este bloque de circuito para poder sincronizar el programa con la señal senoidal de potencia que se quiere controlar. Este circuito enviará un pulso de interrupción cuando la señal cruce por 0, iniciando la rutina correspondiente en el programa.


Aislamiento Control - Potencia:

Se utiliza un optoacoplador 4N35, con la configuración mostrada en la imagen.


Circuito de Potencia:

la configuración de los SCR es como se muestra en la imagen. Esta configuración (2 SCR y 2 Diodos) permite tener un un punto común, utilizada como GND, a diferencia de conectar sólo dos SCR en antiparalelo en el que se requeriría dos señales de control con tierras separadas.


Circuito Completo:


Programa en lenguaje Basic:

$regfile = "m8def.dat"          'Microcontrolador Atmega8

$crystal = 8000000              'Reloj interno 8 MHz

$hwstack = 32                   'Hardware Stack

$swstack = 10                   'Software Stack

Config Portb = Output           'Puerto B como salida



'variables



Dim D As Word                   'Variable para lectura de potenciómetro

Dim T As Single                 'Variable para cálculos

Dim Rampa As Single             'Señal rampa



'configuracion ADC



Config Adc = Single , Prescaler = Auto



'configuracion de interrupciones

Config Int0 = Low Level          'Int. externa. Flanco de bajada

Enable Int0

On Int0 Int_zc

Config Timer1 = Timer , Prescale = 256   'Int. por comparación  31.25 KHz

On Compare1a Int_timer1

Enable Compare1a

Enable Interrupts                'Habilitación de interrupciones



 Timer1 = 0                      'Reinicialización de contador

 Compare1a = 1                   'Interrupción cada 32 us

 Stop Timer1

 Rampa = 0                       'Reiniciar Rampa



'Programa principal

 Do

   nop

 Loop



'Interrupcion cruce por cero



Int_zc:

   Stop Timer1                    'Deterner contador

   Timer1 = 0                     'Reinicializar contador

   Rampa = 0

   Portb.0 = 0                    'Desactivar SCR

   Start Adc

   D = Getadc(0)                  'Leer dato ADC (Potenciómetro)

   Stop Adc

   T = D / 1023

   T = T * 360                    'Rango 0 - 360 => precisión 0.5 grados.

   Start Timer1

   Return



'Interrupción por comparación



Int_timer1:

   Timer1 = 0

   Rampa = Rampa + 2.8           'Incrementar rampa en 2.8

   If T > Rampa Then

      Portb.0 = 0                'Desactivar SCR mientras Rampa < T

   Else

      Portb.0 = 1                'Activar SCR si Rampa > T

   End If

   Return                        'Retorno de interrupción

End

Funcionamiento

Generación de pulsos de interrupción:

Señal en la carga:

Descargar

Diseño de Antena Microstrip Para TV Digital ISDB-T

Diseño de antena microstrip

View more documents from Percy Julio Chambi Pacco

Sensores Inductivos - Completo

Sensores Inductivos

View more documents from Percy Julio Chambi Pacco

Sensores Inductivos - Resúmen

Sensores inductivos

View more presentations from Percy Julio Chambi Pacco

Placa de entrenamiento PIC18F4550

Placa de entrenamiento para microcontrolador PIC18F4550.

Incluye:

• Conector ICSP 6 pines para programación.
• Conector Para USART.
• Conector USB tipo B.
• Pines de puertos I/O (2 x pin).
• Cristal.
• Botón de reset.
• Regulador 5 V.
• Pines VDD/GND (4).
• Switch ON/OFF (Push de 6 pines).
• VDD regulador o puerto USB.

Circuito, Diseño de placa:

Descargar

Programador Pickit 2 Clone

Programador de Pic por USB (Pickit 2 clone)

-Pic 5V
-8/14/18/28/40 pines
-Memorias 24C

Probado con 16F84A / 16F877A / 18f2550 / 18f4550.

Para Programar el PIC18F2550 se utilizó el programador por puerto serial.
Firmware v2.32 y Software Pickit 2 v2.61 disponibles en la página de Microchip.

Esquema Listo para imprimir y lista de componentes:

Pickit 2 Clone

Gráfico de señales eviadas por PIC16F877a en Hp50g

El siguiente programa consiste en:

1. Muestrear una señal analógica de 0 a 5 V con periodo de muestreo
    de 1 segundo por 1 minuto.
2. Convertir las muestras analógicas a digitales.
3. Enviar las muestras digitales a la calculadora HP50g. Transmisión en serie.
4. Convertir las muestras digitales a valores analógicos correspondientes 0-5 V.
5.Graficar la señal continua en tiempo discreto(cada segundo).

En el PIC16F877a

1. La señal analógica se muestrea y se digitaliza utilizando el módulo ADC.

       - Periodo de muestro=1 s
       - 8 bits/muestra

2. Al completarse 60 muestras se pasa a otra rutina de envio de datos por
    USART.

     - 9600 baudios
     - 8 bits de datos
     - 2 bit Stop
     - No paridad

3. Se enciende un Led por 0.5 s indicando transferencia completa.

4. En seguida se toman muestras nuevamente por 1 minuto.

En la calculadora HP50g 

1. Los datos se reciben en la HP50g en forma de cadena.

2. La cadena se separa en caracteres utilizando los comandos HEAD y TAIL.

3. Los caracteres se convierten a valores numéricos (0 - 255) utilizando el
    comando NUM.

4. Los números obtenidos se agrupan en una matríz 1x60.

5. Se convierten los valores digitales a los analógicos correspondientes (0- 5V).

6. Se genera una matríz [0 1 2 ... 59] 1x60 (base de tiempo).

7. La matríz de datos y la matríz base de tiempo forman una matríz 60x2 con los
    comandos AUGMENT y TRAN.

8. Se grafica las muestras (Dispersión) con el comando SCATTER.

9. Se unen los puntos graficados con líneas para un gráfico continuo con el
    comando LINE.


Esquema de circuito:

Programa para PIC16F877a en Pic Basic (Microcode)

'****************************************************************
'*  Name    : graficar_hp50g.BAS                                      *
'*  Author  : LONELY113                                         *
'*  Notice  : Copyright (c) 2011 LONELY113                      *
'*          : All Rights Reserved                               *
'*  Date    : 13/05/2011                                        *
'*  Version : 1.0                                               *
'*  Notes   : PIC16F877a                                        *
'*          : 9600 baudios con cristal de 10 MHz                *
'*          : Pin RC6/Tx a pin RxD de Hp50g                     *
'*          : Pin GND de Hp50g a GND de circuito                *
'*          : Requiere adaptador de nivel 5V a 3.3V             *
'*          : Led en Pin RB4                                    *
'****************************************************************

@ __CONFIG _WDT_OFF & _PWRTE_OFF & _CP_OFF & _HS_OSC & _BODEN_OFF & _LVP_OFF

DEFINE OSC 10          ; 10 MHz

'Definiciones USART
DEFINE HSER_RCSTA 90h  ' Habilitar registro de recepción
DEFINE HSER_TXSTA 20h  ' Habilitar registro de trsnsmisión
DEFINE HSER_BAUD 9600  ' 9600 baudios

'Definiciones ADC
DEFINE ADC_BITS 8      ' Número de bits/muestra
DEFINE ADC_CLOCK 3     ' Fuente de reloj (RC=3)
DEFINE ADC_SAMPLEUS 50 ' Periodo de muestreo en us

TRISB.4=0              'Pin RB4 como salidai VAR BYTE
volt VAR BYTE          'Variable que almacena temporalmente una muestra
signal VAR BYTE[60]    'Variable que almacena 60 muestras
TRISA = 255            'Puerto A como entradas
ADCON1 = 2             'PORTA analógico
PAUSE 5000             'Retardo de 5 segundos

'Inicio de programa
loop1:
 FOR i=0 TO 59          
  ADCIN 0, volt         'Muestrea y guarda en volt
  signal[i]= volt       'signal almacena todas las muestras
  PAUSE 1000            'Muestrear cada segundo
 NEXT

 HSEROUT [STR signal \60] 'Enviar cadena por Tx
 PORTB.4=1                'Encender LED (envio completo)
 PAUSE 500
 PORTB.4=0                'Apagar LED
GOTO loop1
END

Programas para HP50g en UserRPL

Configurar puerto serie

 @Configuracion puerto serie
  <<
    9600 BAUD 0 PARITY
    -33 CF -78 SF
    CLOSEIO OPENIO 1 STIME
  >>

Graficar señal

<<
  {X1 X2 Y1 Y2 j1 j2 m n DATA} PURGE
  
 @Leer datos de Buffer
  BUFLEN
  DROP SRECV DROP 

 @guardar datos en matriz fila 
  DATA STO 
  DATA
  1 60
  FOR i
   DUP HEAD NUM SWAP TAIL
  NEXT
  DROP 60 ROW→ 

 @Convertir a niveles analogicos 0-5V
  255 / 5 *

 @Generar una matriz fila [0 1 2 ...59]
  1 60
  FOR i
   i 1 -
  NEXT 
  60 ROW→ 

 @Formar una matriz 60x2 datos y base de tiempo
  SWAP AUGMENT TRAN
  DUP 'DATA' STO 

 @Graficar muestras (dispersion) 
  ΣDAT STO
  ERASE SCATTER AUTO DRAX DRAW

 @Unir puntos (grafica continua)
  DATA SIZE {m n} STO
  1 m 1 -
  FOR j1
   j1 1 + 'j2' STO
   DATA {j1 1} GET 'X1' STO
   DATA {j1 2} GET 'Y1' STO
   DATA {j2 1} GET 'X2' STO
   DATA {j2 2} GET 'Y2' STO
   X1 Y1 R→C X2 Y2 R→C LINE
 NEXT
 PICTURE
{X1 X2 Y1 Y2 j1 j2 m n ΣDAT ΣPAR PPAR} PURGE
>>

Capturas en pantalla de Hp50g:

Programas *.BAS y HP UserRPL:
Descargar

Placa de entrenamiento PIC16F877A

Placa de entrenamiento para microcontrolador PIC16F877A.

Incluye:

• Conector ICSP 6 pines para programación.
• Conector Para USART.
• Pines de puertos I/O (2 x pin).
• Cristal.
• Botón de reset.
• Regulador 5 V.
• Pines VDD/GND (4).
• Switch ON/OFF (Push de 6 pines).

Circuito, Diseño de placa:


Descargar

Placa de entrenamiento ATmega8

Placa de entrenamiento para microcontrolador ATmega8.

Incluye:

• Conector IDC 2x5 pines para programación.
• Pines de puertos I/O (2 x pin).
• Cristal externo.
• Botón de reset.
• Regulador 5 V.
• Pines VDD/GND (4).
• Pin AREF (opcional 5 V).

Circuito, Diseño de placa:

Descargar

Programación del ATmega8 para el programador USBASP

Programación del atmega8

View more documents from Percy Chambi Pacco

Programador AVR USBASP

Programador de AVR USBASP con ATmega8

Se requiere programar el ATmega8 previamente usando otro programador como puede ser el programador serial junto con Ponyprog2000.

Configuración de fusibles:

HFUSE=0xc9  LFUSE=0xef

firmware, Driver para windows XP:
Descargar

Driver para Windows 7 - 32 / 64 bit:

Descargar

Layout listo para imprimir y lista de componentes:
Descargar

Programador AVR Serial

Programdor AVR por puerto serial.

• Usar con Ponyprog2000: www.lancos.com/prog.html
• Requiere fuente externa de 5V. Conectar entre VDD y GND.

Layout listo para imprimir y lista de componentes:
Descargar

Envio de caracteres de PIC16F877A a calculadora HP50g

Programa para PIC16F877A

Este programa envía una cadena de 10 caracteres a 9600 baudios utilizando transmisión USART.

   Funcionamiento

• Los datos a enviar se encuentran en una tabla de datos en la memoria de programa, en este caso una cadena de 10 caracteres "HOLA MUNDO".
• Se configura el microcontrolador para transmisión serial asíncrona a 9600 baudios (mayor detalle en el archivo . ASM).
• El programa incluye una rutina de retardo antes de enviar los caracteres para poder inicializar la configuración en la calculadora HP50g.
• Se puede conectar un led en el pin RA0. Cuando se conecta la alimentación al pic el led se enciende y se ejecuta la rutina de retardo. Finalizada ésta el led se apaga indicando el inicio de la transmisiñon de datos.
• Los carateres se envian y se almacenan automáticamente en el buffer de entrada de la HP50g una vez abierto el puerto serial con el comando OPENIO.
• El circuito formado por los transistores 2N2222A es un adaptador de nivel de tensión. El PIC trabaja a 0 - 5 V pero la calculadora opera 0 - 3.3 V.

• Crear el siguiente programa en la calculadora y almacenar en una variable. Ejecutar una vez que se conecta la alimetación al PIC16F877A o luego de resetearlo.

                 <<9600 BAUD
                      0 PARITY
                     -33 CF
                     -78 SF
                     CLOSEIO
                     OPENIO
                    10 STIME
                    BUFLEN
                    DROP
                    SRECV
                    DROP
                >>

 Archivos .ASM y .HEX

Descargar

****Programa en Pic Basic (Microcode)****

'****************************************************************
'*  Name    : UNTITLED.BAS                                      *
'*  Author  : LONELY113                                         *
'*  Notice  : Copyright (c) 2011 LONELY113                      *
'*          : All Rights Reserved                               *
'*  Date    : 12/05/2011                                        *
'*  Version : 1.0                                               *
'*  Notes   : PIC16F877a                                        *
'*          : 9600 baudios con cristal de 10 MHz                *
'*          : Pin RC6/Tx a pin RxD de Hp50g                     *
'*          : Pin GND de Hp50g a GND de circuito                *
'*          : Requiere adaptador de nivel 5V a 3.3V             *
'****************************************************************

@ __CONFIG _WDT_OFF & _PWRTE_OFF & _CP_OFF & _HS_OSC & _BODEN_OFF & _LVP_OFF

DEFINE OSC 10         '10 MHz

'Definiciones para USART
DEFINE HSER_RCSTA 90h 'Habilitar registro de recepción
DEFINE HSER_TXSTA 20h 'Habilitar registro de transmisión
DEFINE HSER_BAUD 9600 '9600 baudios

'Inicio de programa
PAUSE 5000            'Retardo de 5 segundos
HSEROUT ["Hola Mundo!!!!!!",13,10] 'Enviar cadena
END

Envio de cadena de caracteres de hp50g a PIC16F877A

Programa para PIC16F877A

Estos dos programas cumplen la misma función que los publicados anteriormente. La diferencia es que se aprovecha la comunicación USART de la que dispone el pic16f877a.


Envio de caracter y visualización en Leds (ASCII)

  Funcionamiento

  El caracter se recibe en el registro RCREG, se mueve al acumulador y se envia al Puerto D para la       visualización.

Envio de una cadena de 16 caracteres

   Funcionamiento

• Se genera una interrupción cada vez que se recibe un caracter.
• La rutina de interrupción guarda los caracteres recibidos en posiciones de memoria sucesivas, mediante direccionamiento indirecto, hasta que se reciben 16 caracteres.
• Una vez recibidos 16 caracteres se pasa a la rutina de visualización en LCD, finalizada ésta se reinicia el programa a la espera de una nueva cadena.

Archivos .ASM y HEX

Envio de caracter

Envio de cadena

Programa para hp50g:

                       << 'a'    PURGE  
                            1    10
                            FOR   j
                               "CADENA   A   ENVIAR"
                               {":a:"  {0 0}   V}
                               INPUT

                                OBJ→    'a'    STO    a

                                9600 BAUD

                                XMIT

                                DROP

                            NEXT

                            'a'   PURGE >>

****Programa en Pic Basic (Microcode)****

'****************************************************************
'*  Name    : UNTITLED.BAS                                      *
'*  Author  : LONELY113                                         *
'*  Notice  : Copyright (c) 2011 LONELY113                      *
'*          : All Rights Reserved                               *
'*  Date    : 12/05/2011                                        *
'*  Version : 1.0                                               *
'*  Notes   : PIC16F877a                                        *
'*          : Pines de LCD:  RD7-RD4=D7-D4  (Modo de 4 bits)    *
'*          :               RB0=RS, RB1=RW, RB2=E               *  
'*          : Pin RC7/Rx=TxD de Hp50g                           *
'*          : unir GND de Hp50g a GND de circuito               *
'*          : Requiere adaptador de nivel 5V a 3.3V             *
'****************************************************************

@ __CONFIG _WDT_OFF & _PWRTE_OFF & _CP_OFF & _HS_OSC & _BODEN_OFF & _LVP_OFF

DEFINE OSC 10 '10 MHz

'Definiciones para módulo LCD
DEFINE LCD_BITS 4      'Bus de 4 bits
DEFINE LCD_LINES 2     'LCD de 2 filas 
DEFINE LCD_DREG PORTD  'Puerto de datos a LCD 
DEFINE LCD_DBIT 4      'Bits 4 a 7 de PORTD
DEFINE LCD_RSREG PORTB 'Puerto B seleccion de registro  
DEFINE LCD_RSBIT 0     'RB0=RS de LCD
DEFINE LCD_RWREG PORTB 'Puerto B Lectura/Escritura  
DEFINE LCD_RWBIT 1     'RB1=RW de LCD 
DEFINE LCD_EREG PORTB  'Puerto B Habilitacionde LCD 
DEFINE LCD_EBIT 2      'RB2=E de LCD 
DEFINE LCD_COMMANDUS 2000 'Retardo ente comandos en us 
DEFINE LCD_DATAUS 50      'Retardo entre datos en us 

'Definiciones USART
DEFINE HSER_RCSTA 90h  'Habilitar registro de recepción
DEFINE HSER_TXSTA 20h  'Habilitar registro de transmisión
DEFINE HSER_BAUD 9600  '9600 baudios

dato VAR BYTE[16]
i VAR BYTE
loop1:
 HSERIN [sTR dato\16] 'Espera 16 caracteres y guarda en dato
 LCDOUT $FE,1         'Borrar LCD
 LCDOUT $FE, $0C      'Primera fila, cursor off
 FOR i=0 TO 15        
  LCDOUT dato[i]      'Enviar 16 caracteres ( en ASCII)
 NEXT i
GOTO loop1
END

Envio de cadena de caracteres y visualización en LCD

Programa para PIC16F84A

• Este programa recibe una cadena de 16 caracteres ASCII de la calculadora HP 50g y la muestra en un LCD con controlador Hitachi 44780.
• Se utiliza Direccionamiento Indirecto para guardar la cadena de caracteres en registros sucesivos a partir de la dirección 20h.
• Los datos en serie se reciben a 9600 baudios por el pin RA4.

Funcionamiento:

• Según el siguiente diagrama de tiempos de envio de datos en serie:

•  El programa espera a que se presente un "0" (bit START). Cuando esto ocurre se ejecuta una rutina que guarda los bits que llegan en serie, a partir del menos significativo, en la dirección de memoria al que apunta el registro FSR (Direccionamiento indirecto). 
• Una vez recibidos los 8 bits, debidamente sincronizados a 9600 baudios mediante retardos, se ejecuta un retardo más a la espera del primer bit STOP (para evitar falsas lecturas de "0" que podría ser el 8 bit de datos).
• Se incrementa FSR para apuntar a la dirección sucesiva y se incrementa un contador de caracteres recibidos.
• Si ya se recibieron 16 caracteres se salta a la rutina que muestra la cadena en un LCD, una vez finalizada se repite el proceso nuevamente . Caso contrario se espera un nuevo "0" (bit START) para recibir el siguiente caracter. 

Diagrama de Conexión:

• La cantidad de caracteres a recibir se puede modificar en el archivo .ASM (donde se indica).

• Opcional: para enviar caracteres desde la calculadora crear el siguiente programa que permite enviar 10 cadenas cada vez que se ejecuta. Escribir la cadena entre comillas (".....") cuando se solicite.

                       << 'a'    PURGE  
                            1    10
                            FOR   j
                               "CADENA   A   ENVIAR"
                               {":a:"  {0 0}   V}
                               INPUT

                                OBJ→    'a'    STO    a

                                9600 BAUD

                                XMIT

                                DROP

                            NEXT

                            'a'   PURGE >>

Archivos .ASM y .HEX:

Descargar

Envio de datos por puerto serie de calculadora HP 50g

Programa para PIC16F84A

• Programa que recibe datos del puerto serie de la HP 50g a 9600 baudios.

• La HP 50g envia caracteres ASCII por el puerto serie (Compatible con interfaz RS232, necesario adaptador de niveles de tensión) según el siguiente gráfico de tiempos:

• Se utiliza el bit START para generar una interrupción por el pin RB0/INT por flanco de bajada.

• La rutina de interrupción guarda los bits de datos recibidos en serie en el registro DATO.

• Se incluye rutinas de retardo para sincronizar a 9600 baudios.

• Una vez finalizada la recepción de datos se muestran los bits (en ASCII) mediante leds en los pines: RB7-RB4 y RA3 - RA0, nibles superior e inferior respectivamente.

• Para enviar un caracter ASCII de la calculadora HP 50g crear el siguiente programa:

                                            <<9600 BAUD XMIT>>

          Guardar en una variable.

• En modo RPN poner el caracter que se desea enviar en el nivel 1 de la pila entre " " y ejecutar el programa.

Esquema de conexión:

El transistor 2N3904 es necesario como adaptador de nivel de tensión ya que la calculadora transmite en niveles CMOS (3.3 V).

Archivos .ASM y .HEX para PIC
Descargar

Se publicará mas información según avance.