Programando pic's desde linux. (config.inc)

Creo que la chamba mas fácil siempre es la de configurar el pic, ponerle las entradas, salidas y activar una que otra bandera de interrupción.

Básicamente diremos lo siguiente.

• Puerto A fue usado para el convertidor analógico digital RA0, RA1, RA2 (Valores de referencia), RA3 (Valores de referencia), RA4 y RA5.
• Puerto B para uso de teclado por su patita RB0/INT Que genera interrupción, y por que se puede programar las patitas RB4-RB7 como interrupción por cambio de estado.
• Puerto C, uso de Led's o cualquier otra cosa que le quieran colgar.
• Puerto D, bus de datos para la pantalla LCD.
• Puerto E, lineas de control para LCD.
  

;************************************************
;Libreria de configuración general del pic.

;***************************************************
;Configura la direccionalidad de los puertos del PIC

Init_Config
bcf STATUS,RP0
bcf STATUS,RP0
clrf PORTA

movlw b'11110000' ;Configiración del puerto B para el teclado
movwf PORTB
call Init_interrup

bsf STATUS,RP0
bcf STATUS,RP1
clrf TRISC

clrf TRISD
clrf TRISE
call Init_ADC
bcf STATUS,RP0

return

;******************************************
;Habilitando interrupciones
Init_interrup
movlw b'11111000'
movwf INTCON

return

;******************************************
;Rutina de configuración del ADC
Init_ADC
;bsf STATUS,RP0
;bcf STATUS,RP1
movlw b'10001100' ;configuramos las entradas del ADC para abrir 3 canales

movwf ADCON1 ;y tener dos valores de referencia.
bcf STATUS,RP0
movlw b'01000000'

movwf ADCON0
return

;******************************************
;Rutina de configuración del Timer1
TMR1_Config
clrf T1CON

bsf STATUS,RP0
bcf STATUS,RP1
bcf PIE1,TMR1IE ;Inhabilitando el desbodamiento del TMR1

bcf STATUS,RP0
clrf TMR1L
clrf TMR1H
bsf PIE1,TMR1IE

movlw 0x36
movwf T1CON
return

Lo basico e indispensable.

Me das la hora?

La verdad es que eso lo hice de rápido y pero la idea es mostrar un while en ensamblador de una forma básica. Espero les pueda servir y bueno, ya luego les pongo el método principal.


__CONFIG _LVP_OFF & _CP_OFF & _PWRTE_ON & _XT_OSC & _BODEN_OFF & _WDT_OFF

list p=pic16f877
include <p16f877.inc>

;Variables
Cont equ 0x20

Hrs equ 0x21
Min equ 0x22
Seg equ 0x23
ContadorC equ 0x24

Temp0 equ 0x25
Temp1 equ 0x26
ContadorB equ 0x27
ContadorA equ 0x28

org 0
goto Principal
org 4
retfie

org 5

Un_Min
movlw d'60'
movwf Temp0

decfsz Temp0,1 ;Este es mi while. Temp0 == 0?
goto retraso_1_seg ;No...
return ;Si!

retraso_1_seg
movlw D'6'
movwf ContadorC

retraso_1_seg_bucle
call sub_delay_1_seg

decfsz ContadorC,1 ; Aquí otro; ContadorC == 0?
goto retraso_1_seg_bucle ;No...
return ;Si!!1

sub_delay_1_seg
movlw D'217'
movwf ContadorB
movlw D'111'

movwf ContadorA

sub_delay_1_seg_bucle
decfsz ContadorA,1
goto sub_delay_1_seg_bucle

decfsz ContadorB,1
goto sub_delay_1_seg_bucle
return

Programando pic's desde linux. (código)

El viernes paso algo muy curioso, el programa no jalo ni hizo lo que tenia. Es mas, ni siquiera hizo algo. Pero como a la par también revisaba el código para el LCD, no me quedo tiempo para debuggear en MPLAB. Y siendo sinceros, no tenia ni idea de algunas partes del código.

Así que valientemente iremos a cazar leones con una varita.

Así que antes de que podamos hacer algo en cuanto al código, hay que saber que hace y por que lo hace.

Primero vamos a configurar el pic.

Código:

Init
bcf STATUS,RP0
bcf STATUS,RP1
clrf PORTA

clrf PORTB
clrf PORTC
clrf PORTE
clrf PORTD

bsf STATUS,RP0
;Desactivando las interrupciones
clrf INTCON
clrf PIE1

;Configurando las patitas del puerto A
movlw 0x8F
movwf ADCON1
;---------------------------
clrf TRISB

clrf TRISE
bsf STATUS,RP0
;Seleccionando la frecuencia de reloj para la conversión. Fosc/8
;ADCS1=0

;ADCS0=1
;ADON=1
movlw 0x41
movwf ADCON0
;Configurando el bit de estado de la conversión.

;GO=1. Iniciandoce la conversión.
bsf ADCON0,GO
bcf STATUS,RP0
return

Ahora veremos que hace la función de leer.

Leer_ADC
;Se concatena IRP con FSR para seleccionar el banco de RAM
;0=Banco 0 y 1 (00h-FFh)
bcf STATUS,IRP
movwf FSR

movf INDF,w
movwf LSB
movlw 0x1E
movwf FSR

movf INDF,w
movwf MSB
bsf ADCON0,GO
return

Programando pic's desde linux. (código)

En este punto, aún puedo escuchar un viejo reclamo de una amiga muy querida que solía decirnos a su novio y a mi: 'Estas como medio obsesionado con la programación. Me das miedo...'

Y siguiendo esa línea y en el mismo mood, se me ha dado la idea de hacer y poner todo un programa comentado para compartirlo con la comunidad estudiantil que lo necesite.

Espero que les pueda servir de algo.

; Programa de muestra hecho para el estudio de mi enanisima!!!

;Bits de configuración.
;LVD_OFF=Programa de voltaje bajo apagado. 

;CP_OFF=Protección de código
;PWRTE_ON=habilita el reset mediante power up timer
;XT_OSC=Se utiliza un cristal de cuarzo
;BODEN_OFF=desabilita el reset por caida de tención.
;WDT_OFF= DESABILITA EL PERRO GUARDIAN.

__CONFIG _LVP_OFF & _CP_OFF & _PWRTE_ON & _XT_OSC & _BODEN_OFF & _WDT_OFF

;Generador de archivos list y llamada a librerias.

 list p=pic16f877
 ;RADIX HEX
 include<p16f877.inc>

;Declaración de variables
 ;b'00000111' Este valor pasa al registro OPTION_REG para configurar el divisor de frecuencia.
 Prescaler equ d'256'
 TMR_50ms equ d'56'

 Cont  equ 0x20
 Cont1  equ 0x21
 Temp  equ 0x22

 
;indicadores del pic16f877

 org 0x00
;Llamando a la rutina de configuración del pic.
 call Init

;Llamando a la rutina principal del programa.
 goto Principal 
 org 4
 retfie
 org 5

;rutinas

Init
 ;Cambiando al banco0.
 bcf STATUS,RP0
 bcf STATUS,RP1

 ;limpiando los puertos
 clrf PORTA
 clrf PORTB
 clrf PORTC

 clrf PORTE
 ;Cambiando al  banco1
 bsf STATUS,RP0
 ;Cambiando puertos de entrada a salida

 ;clrf TRISA
 clrf TRISB
 clrf TRISC
 clrf TRISD

 clrf TRISE
 ;Cambiando al banco0
 bcf STATUS,RP0
 return

confPrescaler
 bcf STATUS,RP1
 bcf STATUS,RP0
 movlw b'00000001'

 movwf OPTION_REG

;Algoritmo proporcionado por Labra Porthela Victor Manuel 
;Lazo anidado.
delay10mS
 movlw d'21'

 call dmS
 return

dmS
 movwf Cont

ciclo
 decfsz Cont,F
 goto dmS1
 return

dmS1

 call d500uS
 nop
 goto ciclo

d500uS
 movlw d'163'

 call duS
 return

duS
 movwf Cont1
 

ciclo1
 decfsz Cont1,F
 goto ciclo1
 return

;Programa principal.

Principal
;Usaremos el puerto A como entrada y el puesto B como salida.
 movlw PORTA
 movf PORTB
 call delay10mS
 goto Principal 
 end

Programando pic's desde linux. (IDE)

Entrando a tema...

El corazón de Pikdev y otros como Piklab, con las herramientas que proporciona GPutils que vimos el post pasado. Por ello veremos como ensamblar desde la línea de comandos.

Abrimos nuestra terminal y nos vamos hasta donde tengamos nuestro archivo '.asm' y tecleamos:

[Sugizo@old practicas]$ gpasm -L -o "/media/disk/escuela/Microcomputadoras/practicas/test01b.hex" -w 2 -I "/usr/share/gputils/header" -p p16f877 -a inhx8m -r hex "/media/disk/escuela/Microcomputadoras/practicas/test01b.asm"

Con ello generaremos el archivo .hex, .cod y .lts que usaremos para GPSim.


Pero si lo que queremos es evitar la terminal, siempre existe el entorno gráfico y sencillo de una IDE como Pikdev.

abrimos nuestro .asm seleccionamos el tipo de pic que deseamos usar y le damos F5 y nos hace lo anterior en un solo click.


y así tenemos los mismos archivos con menos esfuerzo. Hay que aclarar que una de las cosas que debemos cuidar es la sintaxis, ya que gpasm es muy estricto en cuanto a declaraciones. Un error es include, MPLab la reconoce tanto en mayusculas como en minusculas, mientras que gpasm sólo en minusculas.

Ejemplo:

__CONFIG _LVP_OFF & _CP_OFF & _PWRTE_ON & _XT_OSC & _BODEN_OFF & _WDT_OFF
list p=pic16f877
include <p16f877.inc>

Uno siempre se siente realizado cuando se ensambla sin ploblemas... Pero eso no indica que haga lo que debiera y seguramente nos dara dolores de cabeza al ver que pasa nada y lo mismo cuando lo grabamos en el chip. Pero para ello esta GPSim...

Para el programador, solo nos interesa el .hex. Por lo que tomamos como basura todo lo demás. Pero ¿Cómo depuramos?

Desde la terminal tecleamos

[Sugizo@old practicas]$ gpsim -s archivo.cod

Esto nos abre un entorno gráfico simple, aburrido y que parece poco eficiente. Pero su elegancia radica en su simpleza.


En el cual podemos tener todo lo necesario en ventanas independientes y que podemos acomodar en todo el escritorio para poder seguir cada paso de nuestro programa y ver en donde nuestra lógica falla.

Desde esta ventana podemos colocar nuestros breakpoints y seguir línea a línea lo que pasa en nuestro código y lo que tenemos en nuestras librerias auxiliares.


Y en esta esquina tenemos a la maravillosa ventana medidora!! El StopWatch que generosamente nos medirá la cantidad de ciclos y tiempo que tarda una instrucción en ejecutarse.

Y aquí lo tenemos en funcionamiento

Entre sus herramientas tenemos los registros de la RAM como de la memoria EEPROM.


El programa de memoria.

Y una placa gráfica de nuestro integrado donde vienen los puertos y los bits de configuración.


Como dicen: He aquí, todo para el programador. Nos veremos en el siguiente post para seguir descubriendo los horrores de dedo y más código para poder hacer de un pic, una útil herramienta.

Programando pic's desde linux. (Intro)

Ya les había presentado código ensamblador para el 8051 de intel en el cual probaba con un emulador escrito en java y que ensamblaba con nams desde la línea de comandos. Pero ahora es diferente y aquel emulador y mi ensamblador no son suficientes para poder seguir en la recta final.

Ahora estamos probando a la familia de los Pic, el cual ya tenia el gusto de conocer al 16F84. Y para seguir en esa misma línea de trabajo nos topamos ahora con un integrante de la familia mas actual. (Nos referimos al pic16F877)

La compañía que se encarga de fabricar estas bellezas, también se encarga de proporcionar una IDE de forma gratuita para su programación, depuración y grabación en el pic por medio de diferentes programadores, tanto propios como de otras empresas. Pero el problema llega cuando no usas Windows... Ups, te dices y te pones a rezar para que emule vía Wine sin problemas.

Así que me dispuse de tiempo para buscar algún programa para hacer esta tarea de forma nativa en linux, busque y busque y los portales derribe. Encontré un proyecto frances llamado Pikdev que ofrece una IDE sencilla para esta titanica tarea. Pero faltaban las librerías de Microchip para poder hacer mas simple la tarea. Así que pude encontrarlas en el proyecto GPutils, el cual dispone de las herramientas necesarias para poder programar pic y que Pikdev usa.

Pero pronto descubrí un problema mayor y que es el dolor de cabeza de cualquier programador en entorno de producción... bugs... Desgraciadamente, Pikdev no cuenta con un debugger para esto... Cansado de buscar una IDE que me lo dirá, me resigne a emular MPLab de Microchip para poder disponer de la herramienta MPSim para el debuggeo del programa que estaba tronando en el circuito... Pero mis esperanzas murieron cuando active el debugger. Corrió, pero jamás depuro...

Buscando un simulador, di con la pagina de GNUpic que es mantenida por Scott Dattalo. En ella encontré a GPSim, un simulador de pic's y con ello complete el labor de programar y debuggear en un entorno Linux sin necesidad de emular.

Jugando con ensamblador. Que mello!!

Cada que me siento tras una IDE o un editor de textos como emacs o vi, en mi cabeza se invoca la voz de mi amiga Argelia que le reclama a su novio y a mi: Estas como medio obcesionado con la programación. Y como decirles que es mentira. 

Normalmente me dedico a programar en java, c, cuando se requiere en sql estandar y de vez en cuando en algo mas como visual o C#, pero no son lenguajes que me llamen la atención. Pero ahora me ha tocado programar en un viejo amigo complemento de C, si, ensamblador, o como le llamamos: Empalador (Pa' los cuates).

Así que me puse a recordar el set de instrucciones para la serie 8086 (i386) de intel. Pero oh sorpresa que me di, pues el micro que usamos es uno viejito, pero lindo. Me refiero al 8051, y por suerte su set de instrucciones es mas simple, pero mas rarito que el complejo set del i386. Pero ya te tome modo y este es el RC1 para uno de mis proyectos. 

Con ustedes, el código fuente!!! Aplausos, señores!

Este es un programa que manda por el puerto 1 numeros del 1 al F hexadesimal y hace dos sumas. Usa una tabla en apuntadores. 

clr A;
clr C;

mov DPTR, #Tabla ;
mov r3, #0 ;
mov r4, #02 ;
mov 20h, #0Fh ;
mov 30h, #05h ;
mov 31h, #09h ;
mov 32h, #03h ;
 
 ;; led's test
acall test ;
NOP ;
acall separador ;

 ;; Suma

mov A, 30h ;
movc A, @A+DPTR ;
mov P1, A ;
acall tiempito ;
mov A, 32h ;
movc A, @A+DPTR ;
mov P1, A ;
acall tiempito ;
 
 ;; separador de suma
 
acall separador ;

mov A, 30h ;
add A, 32h ;
movc A, @A+DPTR ;
mov P1, A ;
acall Tiempito ;

acall separador ;

 ;; Suma

mov A, 31h ;
movc A, @A+DPTR ;
mov P1, A ;
acall tiempito ;
mov A, 30h ;
movc A, @A+DPTR ;
acall tiempito ;

 ;; Sepaarador de suma
acall separador ;

mov A, 31h ;
add A, 30h ;
movc A, @A+DPTR ;
mov P1, A ;
acall tiempito ;


 ;; tabla
Tabla:
DB 11000000B; 0
DB 11111001B; 1
DB 10100100B; 2
DB 10110000B; 3
DB 10011001B; 4
DB 10010010B; 5
DB 10000010B; 6
DB 11111000B; 7
DB 10000000B; 8
DB 10010000B; 9
DB 10001000B; a
DB 10000011B; b
DB 11000110B; c
DB 10100001B; d
DB 10000110B; e
DB 10001110B; f

 ;; Rutina de retardo

tiempito:
 mov 90h, A;
 mov r0, #02;
 in1: mov r1, #040h;
 in2: mov r2, #090h;

 wait: djnz r2, wait;
  djnz r1, in2;
  djnz r0, in1;
  ret;
 
 ;; Rutina del test

test: mov A, 20h ;
 movc A, @A+DPTR ;
 mov P1, A ;
 acall tiempito;
 mov A, 20h ;
decr: subb A, #01h ;
 mov 21h, A ;
 movc A, @A+DPTR ;
 mov P1, A ;
 acall tiempito ;
 mov A, 21h ;
 jnz decr ;
 ret ;

 ;;Rutina de separador.

separador:
 mov A, #0B6h ;
 mov P1, A ;
 acall tiempito ;
 ret