Contador de eventos hasta 999,999 con interrupciones

Esta es la tercera versión del contador de eventos con el picaxe18M2+, pero esta vez usando interrupciones. Cabe resaltar varios puntos importantes:

*Las interrupciones están por default en el puerto C (revisen el manual para más detalles).

*No se pueden usar interrupciones con multitareas.

*La rutina de interrupción debe de tener el nombre de "interrupt:".

*Asegurarse de habilitar las interrupciones antes del programa principal.

*Los puertos de interrupción son muy pocos, en este  microcontrolador me parece que tiene solo dos (el C.0 y el C.2), pero verifiquen ustedes mismos.

Por esto mismo modifiqué el programa y el diagrama en algunas cosas:

Diagrama:

Programa:
 ;***********************************************************************************************
;    CONFIGURACION DE LOS PUERTOS
;***********************************************************************************************
let dirsB = %11111111        ;Puerto B como salidas digitales
let dirsC = %11001110        ;C.0, C.4 y C.5 como entradas digitales
;***********************************************************************************************
;    INICIALIZACION DE VARIABLES
;***********************************************************************************************
let b1=0
let b2=0
let b3=0
let b4=0
let b5=0
let b6=0
;***********************************************************************************************
;    VECTOR DE INTERRUPCION
;***********************************************************************************************
setint $00000001,00000001
;***********************************************************************************************
;    PROGRAMA PRINCIPAL
;***********************************************************************************************
main:
let pinsB=b6
pulsout B.7,100            ;Se activa solo el transistor de las centenas de millar
let pinsB=b5
pulsout C.1,100            ;Se activa solo el transistor de las decenas de millar
let pinsB=b4
pulsout C.2,100            ;Se activa solo el transistor de las unidades de millar
let pinsB=b3
pulsout C.3,100            ;Se activa solo el transistor de las centenas
let pinsB=b2
pulsout C.6,100            ;Se activa solo el transistor de las decenas
let pinsB=b1
pulsout C.7,100            ;Se activa solo el transistor de las unidades
goto main

;***********************************************************************************************
;    RUTINA DE INTERRUPCION
;***********************************************************************************************
interrupt:
let pinsB=b6
pulsout B.7,100            ;Se activa solo el transistor de las centenas de millar
let pinsB=b5
pulsout C.1,100            ;Se activa solo el transistor de las decenas de millar
let pinsB=b4
pulsout C.2,100            ;Se activa solo el transistor de las unidades de millar
let pinsB=b3
pulsout C.3,100            ;Se activa solo el transistor de las centenas
let pinsB=b2
pulsout C.6,100            ;Se activa solo el transistor de las decenas
let pinsB=b1
pulsout C.7,100            ;Se activa solo el transistor de las unidades
if pinC.0 = 1 then interrupt
setint $00000001,00000001    ;Activamos una vez más la interrupción  
inc b1                ; Se incrementa el contador de unidades en 1
if b1=10 then
    let b1=0
    inc b2
endif
if b2>9 then
    let b2=0
    inc b3
endif
if b3>9 then
    let b3=0
    inc b4
endif
if b4>9 then
    let b4=0
    inc b5
endif
if b5>9 then
    let b5=0
    inc b6
endif
if b6>9 then
    let b6=0
endif
return

Video:

Contador de eventos hasta 999,999 usando multitareas PICAXE18M2+

Con la actual generación de picaxe (M2 y X2) algunos chips como el 18M2+ tienen más capacidades en cada pin. El picaxe18M2+ ahora viene con más salidas y entradas digitales, por lo que podemos controlar más cosas con un solo chip. A diferencia del contador anterior, éste utiliza la nueva función de multitareas. Gracias a esta función podemos realizar varias tareas (hasta 8 con este chip) al "mismo tiempo" como si estuvieran 8 chips en un sólo encapsulado. Para este contador use sólo 3 tareas paralelas. Use 6 displays por que ya no caben más en una protoboard pero se pueden agregar hasta el número de salidas disponibles (menos las 4 que van al 74LS48) que tenga en el microcontrolador. Algo importante de aclarar es que en el anterior contador utilicé resistores de 390 ohms en cada salida del 74LS48 pero al revisar la ficha técnica, leí que no necesita resistores externos y efectivamente los displays que use no los necesitaron porque se ven bien. Pero con algunos de mis compañeros discutimos bastante el tema y observamos que los displays que son más oscuros o casi negros eran los que menos se veían a pesar de llevar resistores (los que yo uso son displays que son muy claros, en tonalidades de gris), y creemos que para que se vean mejor sólo necesitan más corriente y por lo tanto necesitan un 74HC48 y otro transistor con más potencia. Parece que no tiene nada que ver pero ustedes saquen sus propias conclusiones.

Material:
*1 Microcontrolador PICAXE18M2+
*1 IC 74LS48
*6 Displays de siete segmentos cátodo común
*6 Transistores BC547B
*6 Resistores de 820 ohms, 2 de 1000 ohms y 1 de 22000 ohms
*1 Push button

Diagrama:

Programa:

start0:
;***********************************************************************************************
;    CONFIGURACION DE LOS PUERTOS
;***********************************************************************************************
let dirsB = %11111111        ;Puerto B como salidas digitales
let dirsC = %11001111        ;C.4 y C.5 como entradas digitales
;***********************************************************************************************
;    INICIALIZACION DE VARIABLES
;***********************************************************************************************
let b1=0
let b2=0
let b3=0
let b4=0
let b5=0
let b6=0

;***********************************************************************************************
;    PROGRAMA PRINCIPAL
;***********************************************************************************************
main:
let pinsB=b6
pulsout C.0,100            ;Se activa solo el transistor de las centenas de millar
let pinsB=b5
pulsout C.1,100            ;Se activa solo el transistor de las decenas de millar
let pinsB=b4
pulsout C.2,100            ;Se activa solo el transistor de las unidades de millar
let pinsB=b3
pulsout C.3,100            ;Se activa solo el transistor de las centenas
let pinsB=b2
pulsout C.6,100            ;Se activa solo el transistor de las decenas
let pinsB=b1
pulsout C.7,100            ;Se activa solo el transistor de las unidades
goto main

start1:                ;En esta tarea se realiza el conteo
if b1=10 then
    let b1=0
    inc b2
endif
if b2>9 then
    let b2=0
    inc b3
endif
if b3>9 then
    let b3=0
    inc b4
endif
if b4>9 then
    let b4=0
    inc b5
endif
if b5>9 then
    let b5=0
    inc b6
endif
if b6>9 then
    let b6=0
endif
goto start1

start2:
if pinC.5 = 1 then bajo        ;Si es recibido un pulso se espera a que termine el pulso
goto start2
bajo:
if pinC.5 = 0 then incrementa    ;Una vez que termino el pulso se incrementa la variable b1
goto bajo
incrementa:
inc b1
goto start2

Video:

Contador de eventos hasta 9999

Con este proyecto se puede llevar una cuenta de cualquier tipo de eventos, en este caso el contador se activa con un push botton, una aplicación puede ser en un torniquete, donde se cuenta digitalmente cuantas personas han pasado, entre otras.

El programa es el siguiente:
let b1=0
let b2=0
let b3=0
let b4=0
main:                                'Aquí se imprime el número guardado en las variables b1 a b4        
  let b0=128
  let pins=b0|b4
  let b0=64
  let pins=b0|b3
  let b0=32
  let pins=b0|b2
  let b0=16
  let pins=b0|b1
  if input0 is on then otra              'Esperamos a que se presione el botón   
goto main

otra:
  if input0 is off then una             ' Esperamos a que deje de presionar el botón        
goto otra

una:                                           ' Se incrementa el contador de unidades en 1  
  inc b1
  if b1=10 then                          ' Si la unidad llega al diez, que se reinicie en 0            
    let b1=0                               '  y que incremente a las decenas en 1
    inc b2
  endif
  if b2>9 then                           ' Si las decenas llegan a diez, que se reinicie en 0 
    let b2=0                               ' y que incremente a las centenas en 1
    inc b3
  endif
  if b3>9 then                           ' Si las centenas llegan a diez, que se reinicie en 0
    let b3=0                               '  y que incremente a las milésimas en 1
    inc b4
  endif
  if b4>9 then                            ' Si las milésimas llegan a diez, que se reinicie todo
    let b4=0
  endif
goto main

Alarma

Se puede instalar una alarma en cualquier parte además que puede ser activada por un sensor de presencia, de luz, de temperatura, etc., en este caso lo hice con interruptor push button. También se puede cambiar la frecuencia de pítidos del zumbador.

El programa es el siguiente:
main:
  high 1                                     'Se prende el verde
  if pin3 is on then otro
  goto main
otro:
  if pin3 is off then prende
  goto otro
prende:                                     'Se prende la alarma
  low 1
  high 4
  high 2
  if pin3 is on then otra
  pause 50
  low 4,2
  pause 50
  goto prende
otra:
  if pin3 is off then apaga
  goto otra
apaga:
  low 4
  low 2
goto main

Semáforo

Con tan sólo tres salidas del picaxe-18M se puede obtener la frecuencia de cada led. Para obtener un semáforo real se tiene que utilizar un relevador en cada salida pero eso vendrá más adelante.

El programa es el siguiente:
semaforo:
low 7
high 4 'Prende el verde 5 segundos
wait 5
low 4
pause 300
for b0=0 to 1 'Parpadea el verde
   high 4
   pause 300
   low 4
   pause 300
next b0
high 5 'Prende el amarillo 2 segundos
wait 2
low 5
high 7 'Prende el rojo 7 segundos
wait 7
goto semaforo

Luces tipo auto fantástico

En este proyecto se muestra cómo se pueden manipular las 8 salidas del PICAXE-18M. Se pueden hacer múltiples combinaciones en la frecuencia que se desee.

El programa es el siguiente:
main:
let pins=0
for b1= 0 to 1
   for b0=0 to 7    'Prende y apaga los led uno por uno del primero al último
      let pins=0
      high b0
      pause 50
   next b0
   for b0=7 to 0 step -1  'Prende y apaga los led uno por uno del último al primero        
      let pins=0
      high b0
      pause 50
   next b0
next b1
goto main