Escritura y Lectura de memorias eeprom externas 24LCxxB (16F630 16F676)

En ocasiones necesitamos guardar información en memoria que no debe perderse si la fuente de alimentación de nuestro circuito deja de funcionar.
Para ello se puede utilizar la memoria interna eeprom del micro. Sin embargo, esta memoria no suele ser muy gande. Es entonces cuando podemos utilizar las memorias eeprom externas.

En el mercado hay una gran variedad de memorias de este tipo. Vamos a trabajar con la familia 24LCxxB de Microchip, que utiliza la interfase I2C.
Los números presentes en los dígitos xx indican el número de kilobits de la memoria. Por ejemplo, el código 24LC04B nos indica que tenemos 4kilobit de memoria (4016 bits), lo cual equivale a 512 bytes. Esta es la memoria que vamos a utilizar para nuestro proyecto.

Las memorias de 1,2,4,8 y 16 Kbits tienen una dirección de acceso única, sin embargo las memorias de mayor capacidad (32Kb, 64Kb,etc) disponen de tres pines para establecer la dirección de acceso al chip.

Otra característica de las memorias de menor capacidad es que deben ser accesadas por bancos de 256 bytes. Esto quiere decir que en nuestro caso tenemos 2 bancos de 256 bytes.

Si utilizamos el compilador PICBASIC PRO para programar el micro tenemos a nuestra disposición las instrucciones I2CREAD e I2CWRITE para leer y escribir en la memoria. El tercer parámetro de estas instrucciones (control) indica , entre otras cosas, el banco en el cual estamos trabajando. De tal forma que si queremos leer alguna posición desde 0 hasta 255 , debemos indicar que trabajamos con el banco 0, y para posiciones superiores a 255 debemos indicar que vamos a trabajar con el banco 1.

En el programa anexo hemos elaborado dos subrutinas de lectura/escritura que generan automaticamente los bits correspondientes.

'**************************************************************** '* Name : eep02.BAS * '* Author : JLG * '* Notice : Copyright (c) 2015 * '* Device : 16F630 * '* Date : 06/03/2015 * '* Version : 1.0 * '* Notes : 24LC04B 512Bytes 2 banks * '**************************************************************** @ __config _INTRC_OSC_NOCLKOUT & _WDT_ON & _MCLRE_ON & _CP_OFF Include "modedefs.bas" vars: eee_size con 511 ' external eeprom size minus 1 (512 -1 = 511) MODE var word ' WORD for MODE value PICSO var PORTA.5 ' Defines PORTA.5 name as PICSO DPIN Var PORTC.4 ' I2C data pin CPIN Var PORTC.5 ' I2C clock pin cont var byte B1 Var byte B3 Var byte bank var byte addr0 var word addr1 var byte init: TRISA = 1000 ' PORTA output except pin 3 (MCLR ) TRISC = 0000 ' PORTC output CMCON = 7 ' No comparator Define OSCCAL_1K 1 ' Set OSCCAL for 1K flash DEFINE OSC 4 ' 4 MHz OSC mode = 188 ' 4800bps for 4Mhz clock PORTA=0 PORTC=0 pause 500 Serout2 PICSO,mode,[" ",10,"Writing eeeprom",10] for addr0 = 0 to eee_size gosub eeer_write next addr0 mainloop: Serout2 PICSO,mode,[10,10,"eeeprom values",10,"0000 "] B3=0 for addr0 = 0 to eee_size gosub eeer_read if b1>15 then Serout2 PICSO, Mode,[ihex (B1)," "] else Serout2 PICSO, Mode,[" ",ihex (B1)," "] endif b3 = B3 + 1 if (B3 >15) and (addr0<eee_size ) then if addr0=15 then Serout2 PICSO, Mode,[10,"0010 "] else Serout2 PICSO, Mode,[10,hex4 addr0+1," "] endif B3=0 endif next addr0 Serout2 PICSO, Mode,[10] pause 15000 goto mainloop eeer_read: bank = addr0 / 256 addr1= addr0 - (256 * bank) cont = $A0 + ( bank * 2 ) I2CREAD DPIN,CPIN,cont,addr1,[B1] return eeer_write: bank = addr0 / 256 addr1= addr0 - (256 * bank) cont = $A0 + ( bank * 2 ) I2CWRITE DPIN,CPIN,cont,addr1,[addr1] Pause 10 return End
En la sección init: escribimos en cada posición de memoria el primer byte de su dirección.
En la sección mainloop: leemos la memoria y mostramos el contenido en la pantalla del ordenador mediante un puerto serial/software.

En la pantalla adjunta podemos ver el resultado de la escritura/lectura en la utilidad Serial Communicator del compilador PICBASIC PRO

Programadores PIC

Un programador es un dispositivo que nos permite grabar en la memoria flash del micro el código hexadecimal generado por el compilador/ensamblador de nuestra preferencia.
Tenemos dos opciones: Adquirir uno en el mercado o construirlo nosotros mismos.
Los programadores mas populares son los de la empresa Microchip o sus clones, ya que esta empresa liberó los esquemas electrónicos de los mismos asi como también el software asociado.
Originalmente estos dispositivos utilizaban los puertos serial o paralelo para comunicarse con el computador. Hoy en día estos puertos han sido sustituidos por puertos USB.
Hay dos posibilidades para conectar el micro al que deseamos grabar el código hexadecimal:

• Mediante una base donde se coloca el micro
• Mediante programación en el circuito (ICSP) : No tenemos que retirar el micro del circuito, sin embargo, no todos los micros aceptan esta tecnología.

A continuación una relación reducida de algunos programadores:

• PICkit 2 
• PICkit 3
• usbpicprog : Es un programador USB open source basado en un micro 18F2550
• JDM2 : Versión actualizada del mítico programador por puerto serial JDM
• Open Programmer: Programador USB open source muy completo basado en el 18F2550.
• Arduino como programador para 18F2550
• Arduino como programador para la familia 16
• Arduino como programador de la familia 12
• Otra versión de Arduino como programador PIC
• Arduino como programador del PIC32MX

El programador requiere para su utilización del software necesario para grabar el archivo hexadecimal en el micro.
Algunos programas disponibles:

• PICPgm
• WinPicProg
• WinPic800
• EPICWin
• PonyProg 
• IC-Prog 

Reloj interno, cristal o resonador ?

Cuando trabajamos en un proyecto una de las decisiones que debemos tomar está relacionada con el oscilador del microcontrolador.
En general tenemos tres opciones : Reloj interno del micro (en caso de que lo tenga), cristal de cuarzo o resonador cerámico.
A continuación las ventajas y desventajas:

• Reloj interno: Es la opción mas económica ya que no necesitamos adquirir componentes adicionales. Por otro lado dejamos libres dos pines del micro que pueden ser utilizados como puertos de entrada/salida. La desventaja es su precisión, que por lo general tiene un error del 1%.
• Resonador cerámico: Es la opción mas económica si necesitamos mayor precisión. El error suele estar entre 0.1% y 1%. Además del costo de un componente adicional tenemos que dedicar dos pines para su conexión.
• Cristal de cuarzo : Es la opción mas precisa , en el rango de 10 a 50 partes por millón, aunque mas costoso que el resonador. Al igual que con el resonador debemos utilizar dos pines del micro y se requiere adicionalmente dos condensadores iguales entre los dos pines y tierra , por lo general de 22pf o 33pf.

 En resumen podríamos decir:

• Un proyecto personal : Utilizar el reloj interno del micro. En caso de que no lo tenga utilizar un cristal de cuarzo. La diferencia de precio con el resonador es asumible.
• Proyecto masivo donde no se necesita precisión y no se dispone de reloj interno: Usar el resonador. La diferencia en precio con el cristal se vuelve significativa cuando hablamos de cantidades grandes.
• Proyecto donde se requiere preción: Utilizar cristal de cuarzo.

Contador con display de siete segmentos 16F630

Este proyecto utiliza todos los pines del micro 16F630 y su objetivo es desarrollar un contador de minutos/segundos utilizando un display cuadruple de 7 segmentos.

Como podemos ver en la figura no utilizamos resistencias para los segmentos , las utilizamos para los pines de selección de cada dígito, con lo que la luminosidad será diferente dependiendo del número mostrado.
El boton de reset permite iniciar el contador a 00:00
Tomando en cuenta que se utiliza el oscilador interno, la precisión no es muy buena (se adelanta un segundo cada 10 minutos con el micro utilizado).
El programa se muestra a continuación:

'**************************************************************** '* Name : clock00.BAS * '* Author : JLG * '* Notice : Copyright (c) 2015 * '* Device : 16F630 * '* Date : 06/03/2015 * '* Version : 1.0 * '* Notes : * '**************************************************************** @ __config _INTRC_OSC_NOCLKOUT & _WDT_ON & _MCLRE_ON & _CP_OFF vars: ticks Var byte ' Define pieces of seconds variable update Var byte ' Define variable to indicate update i Var byte j Var byte sec var byte minute var byte digit var byte A var byte D var byte init: TRISA = 1000 ' PORTA output except pin 3 ( MCLR ) TRISC = 0000 ' PORTC output CMCON = 7 ' No comparator Define OSCCAL_1K 1 ' Set OSCCAL for 1K flash DEFINE OSC 4 ' 4 MHz OSC PORTA=0 PORTC=0 OPTION_REG = %11010101 ' $D5 Set TMR0 configuration ' 101 prescaler 1:64 every 16.384 ms INTCON = %10100000 ' $A0 Enable TMR0 interrupts On Interrupt Goto tickint ticks = 0 update = 1 sec = 0 minute = 0 mainloop: If update = 1 Then INTCON = %10000000 ' $80 No interrupts sec = sec + 1 if sec = 60 then sec = 0 minute = minute +1 if minute=60 then minute=0 endif update = 0 ' Screen updated INTCON = %10100000 ' $A0 Enable TMR0 interrupts Endif gosub display_n goto mainloop Disable ' Disable interrupts during interrupt handler tickint: ticks = ticks + 1 ' Count pieces of seconds If ticks = 61 Then update=1 ticks = 0 endif INTCON.2 = 0 ' Reset timer interrupt flag Resume enable End display_n: D = 01 : DIGIT = minute dig 1 : gosub LOOk D = 10 : DIGIT = minute dig 0 : gosub LOOk D = %0100 : DIGIT = sec dig 1 : gosub LOOk D = %1000 : DIGIT = sec dig 0 : gosub LOOk PORTA.5 = 0 Return LOOK : PORTC.4 = 0 PORTC.5 = 0 PORTA.4 = 0 PORTA.5 = 0 Lookup DIGIT,[%1000000,%1111001,%0100100,%0110000,11001,10010,00011,%1111000,00000,11000],A PORTA.0 = A PORTA.1 = A >> 1 PORTA.2 = A >> 2 PORTC.0 = A >> 3 PORTC.1 = A >> 4 PORTC.2 = A >> 5 PORTC.3 = A >> 6 PORTC.4 = D PORTC.5 = D >> 1 PORTA.4 = D >> 2 PORTA.5 = D >> 3 pause 5 RETURN
El proyecto utiliza interrupciones generadas por el reloj interno TMR0 .
Es interesante mencionar la línea al principio del programa :

  @  __config _INTRC_OSC_NOCLKOUT & _WDT_ON & _MCLRE_ON & _CP_OFF 

Esta línea establece los parámetros del micro (fuses), ya que en el archivo 16F630.INI se comentó la misma línea para poder incorporarla en todos los programas y seleccionar los  valores de interés.

PIC Fuses PICBASIC Pro

Cuando compilamos un programa en PICBASIC Pro el compilador agrega a nuestro código las definiciones presentes en el archivo INC correspondiente al micro utilizado.
Si por ejemplo estamos utilizando el micro 16F630 tendremos el siguiente contenido:

;**************************************************************** ;* 16F630.INC * ;* * ;* By : Leonard Zerman, Jeff Schmoyer * ;* Notice : Copyright (c) 2005 microEngineering Labs, Inc. * ;* All Rights Reserved * ;* Date : 08/31/05 * ;* Version : 2.46a * ;* Notes : * ;**************************************************************** NOLIST ifdef PM_USED LIST include 'M16F630.INC' ; PM header device pic16F630, intrc_osc_noclkout, wdt_on, mclr_on, protect_off XALL NOLIST else LIST LIST p = 16F630, r = dec, w = -302 INCLUDE "P16F630.INC" ; MPASM Header __config _INTRC_OSC_NOCLKOUT & _WDT_ON & _MCLRE_ON & _CP_OFF NOLIST endif LIST Podemos observar que dependiendo del ensamblador que utilicemos (PM o MPASM) el encabezado es diferente.
Si quisieramos modificar alguno de los fusibles en nuestro programa, por ejemplo deshabilitar la función MCLR del micro 16F630 y utilizar el pin en su función como PORTA.3 , tenemos dos opciones:

• Modificar el archivo 16F630.INI y colocar _MCLRE_OFF en lugar de _MCLRE_ON (para MPASM). En este caso la modificación aplicaría para todos los programas que compilemos.
• Comentar la línea en el archivo 16F630.INI colocando punto y coma al principio de la misma, y agregando la línea @  __config _INTRC_OSC_NOCLKOUT & _WDT_ON & _MCLRE_ON & _CP_OFF  al principio de nuestro programa (en el caso de MPASM). De esta forma podemos seleccionar valores diferentes para cada programa.

Interrupciones por Reloj 16F630

Ya sabemos que los micros PIC tienen relojes internos (de 8 y 16 bits) y manejan interrupciones.
La combinación de estos dos conceptos permite la generación de una interrupción a partir de uno de los relojes internos del micro.
Aunque el concepto es sencillo, para su implementación hay que ser muy cuidadoso y tomar en cuenta varios puntos fundamentales.
Vamos a analizar un programa muy sencillo en PICBASIC Pro  (basado en otros aportes de la web) utilizando el micro 16F630. El objetivo del programa es encender y apagar un led  conectado al pin 0 del puerto A (se utiliza un led colocado en el pin 1 del mismo puerto para validar cada vez que se produce una interrupción).

'**************************************************************** '* Name : int01.BAS * '* Author : JLG * '* Notice : Copyright (c) 2015 * '* Device : 16F630 * '* Date : 06/03/2015 * '* Version : 1.0 * '* Notes : * '**************************************************************** vars: ticks Var byte ' Define pieces of seconds variable update Var byte ' Define variable to indicate update of LCD init: TRISA = 1000 ' PORTA output except pin 3 ( MCLR ) TRISC = 0000 ' PORTC output CMCON = 7 ' No comparator Define OSCCAL_1K 1 ' Set OSCCAL for 1K flash DEFINE OSC 4 ' 4 MHz OSC PORTA=0 PORTC=0 OPTION_REG = %11010101 ' $D5 Set TMR0 configuration ' 101 prescaler 1:64 every 16.384 ms INTCON = %10100000 ' $A0 Enable TMR0 interrupts On Interrupt Goto tickint ticks = 0 update = 1 mainloop: If update = 1 Then INTCON = %10000000 ' $80 Disable TRM0 interrupts toggle PORTA.0 update = 0 INTCON = %10100000 ' $A0 Enable TMR0 interrupts Endif goto mainloop Disable ' Disable interrupts during interrupt handler tickint: toggle PORTA.1 ticks = ticks + 1 ' Count pieces of seconds If ticks <61 Then tiexit update=1 ticks = 0 tiexit: INTCON.2 = 0 ' Reset timer interrupt flag Resume enable End
Puntos a considerar:

• Vamos a utilizar el oscilador interno del micro. En el caso del 16F630 ( y otros ) se necesita calibrar dicho oscilador. Para ello se utiliza la instrucción  Define OSCCAL_1K 1  (ya que tenemos un micro con 1K de flash, en el caso de micros con 2K de flash la instrucción sería Define OSCCAL_2K 1 ). Esta instrucción toma un valor grabado de fábrica ubicado en las posiciones finales de la memoria flash, de ahí la importancia de indicar si el micro tiene 1K o 2K de flash.
• Como el reloj interno es de 4Mhz, debemos indicarle al compilador dicho valor mediante la instrucción DEFINE OSC 4 .
• Lo siguiente que debemos hacer es utilizar los registros internos del micro  para establecer los parámetros del timer y las interrupciones. Para ello tenemos que revisar la hoja de especificaciones del micro que estemos utilizando.  En nuestro caso, para el 16F630, dichos registros son OPTION_REG e INTCON.
• La instrucción OPTION_REG = %11010101 permite utilizar un divisor  de 1/64 , lo que equivale a 16.384 milisegundos.
• La instrucción INTCON  = %10100000 activa las interrupciones en general y la del reloj en particular.
• La instrucción On Interrupt Goto tickint permite que cada vez que ocurra una interrupción se ejecute el codigo ubicado en la etiqueta tickint.
• Revisando el código de la etiqueta tickint podemos ver los siguientes detalles:
• Antes de la etiqueta tickint tenemos la instrucción DISABLE , ya que no queremos que ocurran otras interrupciones mientras estamos procesando la presente.
• La instrucción INTCON.2 = 0 al final de la sección permite poner a cero el reloj
• La instrucción RESUME permite regresar al código donde estabamos antes de la interrupción.
• ENABLE habilita de nuevo las interrupciones
•  En el lazo principal (mainloop) procesamos el valor de la variable update . Como tampoco queremos que ocurran otras interrupciones mientras ejecutamos este código, utilizamos las instrucciones INTCON = %10000000 e INTCON = %10100000 que deshabilita y habilita las interrupciones a partir del reloj interno.

En la literatura disponible en la web hay cierta confusión en relación a la ubicación de las instrucciones ENABLE y DISABLE .  En una subrutina lo lógico es que estas instrucciones estén dentro de la misma, pero en este caso no es una subrutina, por lo que su posición es diferente.

También debemos considerar que la interrupción se ejecuta entre instrucciones, por lo que si estamos ejecutando una instrucción particular, como SERIN/SERIN2 , la interrupción se procesará después de ejecutarse la misma.

Microcontroladores PIC

Mis primeras experiencias con microcontroladores fueron hace muchos años, y con la familia MCS-51 de la Intel (años aquellos). Después de mucho tiempo alejado del tema, volví a los micros a traves del Arduino. Que diferencia !!!

Arduino es un concepto  muy interesante y muy exitoso que trasciende los micros Atmel.

Parece dificil de creer, pero aunque había oido de los micros PIC de Microchip, no había tenido la oportunidad de "jugar" con ellos.

Recientemente me decidí  a probar las bondades de estos micros.

Y entonces me di cuenta de las diferencias entre el Arduino y la familia PIC.

Mi idea no es contribuir a la controversia entre PIC y Arduino. Creo que muchas veces lo que vemos en la red realmente no aporta ningún valor.

Mi opinión es que son dos conceptos diferentes, cada uno tiene sus ventajas y sus desventajas, que se manifestarán dependiendo del proyecto en cuestión.

Y el punto es ese, si podemos decidir, lo mas sabio es seleccionar el micro que mas se adecue a nuestras necesidades.

Entonces entremos en materia.

Para trabajar con un micro PIC debemos tener:

• Un PC. En mi caso voy a trabajar con un portatil con el S/O windows Vista.
• Un programador de PICS : Hay muchos en el mercado. Yo me decidí por un clon del PICKit2
• Un programa para grabar el PIC : En mi caso viene con el programador
• Un ambiente de desarrollo
• Un micro PIC

Los tres primeros requisitos son los mas sencillos, pero los dos últimos son para meditar.

La razón es que en el mercado hay muchos ambientes de desarrollo y la empresa Microchip tiene una cantidad impresionante de diferentes micros.

En otra entrada detallaré mi experiencia con diferentes ambientes de desarrollo, sin embargo, por los momentos, me decidi por la combinación del IDE Micro Code Studio y el compilador PICBASIC Pro

En relación al micro, empecé por dos de la gama baja:

• 12F675 : 8 pines, 1KW flash, 64B ram,128B rom, 6 puertos, 4 A/D 10 bits
• 16F684 : 16 pines, 2KW flash, 128B ram, 256B rom, 12 puertos, 8 A/D 10 bits

Tal vez mi decisión parecerá muy modesta, pero siempre me ha interesado el sacar el máximo provecho de un micro, y mas importante, no deja de deslumbrame lo que podemos hacer con un micro de 8/16 pines !!!

El proyecto que voy a presentar tiene por objeto utilizar varias funcionalidades del 16F684:

• Uso de pines digitales para encender/apagar leds
• Comunicación serial a traves de cualquier pin
• Generación de sonido mediante un altavoz conectado a un puerto digital

El programa utilizado (tomando como base aportes previos en la web) es el mostrado a continuación:

'**************************************************************** '* Name : TEST00.BAS * '* Author : JLG * '* Notice : Copyright (c) 2015 * '* Device : 16F684 * '* Date : 06/03/2015 * '* Version : 1.0 * '* Notes : * '**************************************************************** Include "modedefs.bas" vars: MODE var word ' WORD for MODE value Command var byte ' BYTE for Command value LED1 var PORTA.0 ' Defines PORTA.0 name as LED1 LED2 var PORTA.1 ' Defines PORTA.1 name as LED2 LED3 var PORTA.2 ' Defines PORTA.1 name as LED3 PICSI var PORTC.0 ' Defines PORTC.0 name as PICSI PICSO var PORTC.1 ' Defines PORTC.1 name as PICSO LEDS VAR PORTA B0 var byte B1 var byte B3 var byte init: TRISA = 1000 ' PORTA output except pin 3 ( MCLR ) ANSEL = 0 ' Changes analog bits to digital. OSCCON = $70 ' Sets the internal clock to 8MHz define OSC 8 ' Compiler must know de new frequency CMCON0 = 7 ' No comparador TRISC.0 = 1 ' Port C0 input mode = 84 ' 9600bps, 8bits, no parity, 1 stop bit gosub leds_show Serout2 PICSO, Mode, ["Initializing...",10,13] gosub help mainloop: Command=0 serin2 PICSI,Mode, 30000,timeout,[Command] Select case Command case "a" HIGH LED1 Serout2 PICSO, Mode, ["LED1 ON",10,13] case "b" low LED1 Serout2 PICSO, Mode, ["LED1 OFF",10,13] case "c" HIGH LED2 Serout2 PICSO, Mode, ["LED2 ON",10,13] case "d" low LED2 Serout2 PICSO, Mode, ["LED2 OFF",10,13] case "e" low LED1 low LED2 Serout2 PICSO, Mode, ["LED1,LED2 OFF",10,13] case "f" high LED1 high LED2 Serout2 PICSO, Mode, ["LED1,LED2 ON",10,13] case "l" gosub leds_show case "h" gosub help: case "r" Serout2 PICSO, Mode, ["Read EEPROM",10,13] B3=0 Serout2 PICSO, Mode,["00 "] For B0 = 0 To 255 Read B0,B1 if b1>15 then Serout2 PICSO, Mode,[ihex (B1)," "] else Serout2 PICSO, Mode,[" ",ihex (B1)," "] endif b3 = B3 + 1 if (B3 >15) and (B0<255) then if b0=15 then Serout2 PICSO, Mode,[10,13,"0F "] else Serout2 PICSO, Mode,[10,13,hex B0+1," "] endif B3=0 endif Next B0 Serout2 PICSO, Mode,[10,13] case "v" Serout2 PICSO, Mode, ["Write EEPROM with address",10,13] B3=0 For B0 = 0 To 255 write B0,b0 Next B0 case "z" Serout2 PICSO, Mode, ["Write EEPROM with FF",10,13] B3=0 For B0 = 0 To 255 write B0,0 Next B0 end select GoTo mainloop timeout: Serout2 PICSO, Mode, ["Timeout",10,13] SOUND PORTC.5,[100,10,50,10] GoTo mainloop End help: serout2 PICSO, MODE, ["Type command:",10,13] serout2 PICSO, MODE, [" a on LED1",10,13] serout2 PICSO, MODE, [" b off LED1",10,13] serout2 PICSO, MODE, [" c on LED2",10,13] serout2 PICSO, MODE, [" d off LED2",10,13] serout2 PICSO, MODE, [" e off LED1,LED2",10,13] serout2 PICSO, MODE, [" f on LED1,LED2",10,13] serout2 PICSO, MODE, [" l leds show",10,13,10,13] serout2 PICSO, MODE, [" r read EEPROM",10,13] serout2 PICSO, MODE, [" v write EEPROM with address",10,13] serout2 PICSO, MODE, [" z write EEPROM with FF",10,13] Return leds_show: LEDS = 0 LEDS = 1 : Pause 500 LEDS = %010 : Pause 500 LEDS = %100 : Pause 500 LEDS = 0 : Pause 500 LEDS = %111 : Pause 500 LEDS = 0 : Pause 500 LEDS = %111 : Pause 500 LEDS = 0 : Pause 500 Return    

Un punto a tener en consideración del programa mostrado es que se trata de ordenar en secciones las diferentes funciones del mismo, lo cual le da "elegancia" y ayuda mucho a la hora de realizarle modificaciones.

Para poder utilizar la interfase serial debemos conectar un convertidor serial/usb a los puertos C.0 y C.1

Adicionalmente debemos hacer uso de un programa de comunicación serial en nuestro PC (uno muy utilizado es putty), sin embargo yo utilizo uno propio (MiniTerminal).

Podemos ver en la imágen el mensaje inicial del micro y la ejecución del comando r

El altavoz va conectado al pin C.5 mediante un condensador electrolítico de 10uF