En este tema, iremos colocando los link o material de descarga para este lenguaje gratuito y que promete un gran futuro.

Descargar la última versión de JALv2 estable

Bibliotecas.

Más biblioteca.

Hola a todos. Con Ariel, usuario de este foro y creador del foro de Ucontrol estamos creando una serie de ejemplos de programación de este lenguaje.

Con el permiso de él, subiré los ejemplos de él y los míos. Son bienvenidos los aportes que todos ustedes puedan y quieran hacer.

A partir de este mensaje, hay una serie de ejemplos de programación con el lenguaje JALv2. No hay demasiado material sobre este compilador, así que es posible que esta pequeña colección de ejemplos sea un buen punto de partida para comenzar a utilizarlo.

Los ejemplos van a utilizar solamente el compilador JALv2 (gratuito) y la placa entrenadora Multiboard PIC Trainer (gratuita) diseñada por Felixls. Para poder llevar a cabo los diferentes ejercicios utilizaremos algunos módulos del PIC TRAINER de uControl (gratuito también).


Este es el pin-out de la placa que utilizamos.


El PIC que voy a utilizar como base para los ejemplos es el PIC18F4550, que tiene mucho para ofrecer por muy poco dinero Por supuesto, nada impide que -en la mayoría de los ejemplos- utilices prácticamente cualquier otro micro, simplemente cambiando el encabezado del código fuente y volviendo a compilar.



001 - LED parpadeando con 18F4550

002 - 2 LEDs parpadeando alternadamente con 18F4550

003 - 8 LEDs "Coche Fantástico" con PIC18F4550 (Versión 1)

004 - PWM con un Led. PIC16F877A (versión 1)

005 - 8 LEDs "Coche Fantástico" con PIC18F4550 (Versión 2)

006 - PWM con dos efectos seleccionable con 2 pulsadores (PIC16F877A)

007 - LCD Alfanumérico - Ejemplo 01

008 - LCD Alfanumérico - Ejemplo 02

009 - ADC y LCD

010 - ADC, LCD y EEPROM

Este es el "hola mundo" de los programas para PIC: un led que enciende y apaga continuamente, controlado mediante un pin E/S del microcontrolador.


Esta es la parte más importante del programa:

-- Incluyo la librería que contiene las rutinas de demoras:
include delay

-- Configuro los pines de E/S------------------------------------------------
enable_digital_io()          -- Todos los pines configurados como E/S
alias LED1  is pin_b7        -- LED1 será equivalente al pin 40 (RB7)
pin_b7_direction = output    -- El pin que tiene el LED es una SALIDA
LED1 = off                   -- Apago el LED1

-- Declaro las constantes y variables a utilizar en el programa -------------
const word tiempo_encendido  = 500  -- Milisegundos que permanecerá encendido.
const word tiempo_apagado    = 500  -- Milisegundos que permanecerá apagado.

-- --------------------------------------------------------------------------
-- Comienzo del bucle principal del programa 
-- --------------------------------------------------------------------------

forever loop  -- Bucle que se repite indefinidamente
        LED1 = on                    --Enciendo el LED1...
        delay_1ms(tiempo_encendido)  --Y espero el tiempo prefijado
        LED1 = off                   --Apago el LED1...
        delay_1ms(tiempo_apagado)    --Y espero el tiempo prefijado
end loop      -- Fin del bucle.

- Fin del programa

Como puede verse, el código es muy simple y está comentado. Si tienes alguna duda, utiliza el hilo especial para los comentarios y sugerencias

Veamos que es lo que hace cada una de las instrucciones que hemos utilizado:

- En primer lugar, tenemos que saber que cada linea que comienza con "--" o con ";" es un comentario y es ignorada por el compilador. Como ocurre en cualquier lenguaje de programación, es muy conveniente utilizar los comentarios para documentar el código que uno escribe. Esto lo hace mucho más legible para los demás (y para uno mismo )

- include delay le indica al compilador que incluya la libreria "delay". En ella (puedes ver su código dentro de la carpeta "jalv2/lib/" de tu ordenador) se encuentran las rutinas encargadas de proporcionar retardos.

- enable_digital_io() hace que todos los pines del micro se comporten como pines de E/S digital. De esa manera, se deshabilitan comparadores, conversores A/D y cualquier otra función semejante.

- alias LED1  is pin_b7   hace que podamos utilizar la cadena "LED1" en lugar de "pin_b7". Esto se denomina "alias" y es un recurso muy interesante, ya que si nuestro hardware cambia (por ejemplo, conectando el led al pin RD3) simplemente hay que cambiar esa linea y el resto del programa permanece inalterado.

- pin_b7_direction = output configura el pin en que se encuentra el led (pin_b7) como salida.

- LED1 = off hace que la salida en la que está el led -fijate: hemos utilizado el alias en lugar de pin_b7-   se ponga en cero. JALv2 proporciona muchas formas equivalentes de decir "cero": off, low, 0 y false  son algunas de ellas.

- const word tiempo_encendido  = 500  crea una constante -una región de la memoria del micro en la que se alojará un valor que permanecerá inalterado a lo largo de todo el programa- del tipo "word" (dos bytes) llamada "tiempo_encendido" y le asigna el valor (decimal) "500".

- forever loop .... end loop es una estructura de control. Todas las sentencias que se encuentran entre una y otra de estas instrucciones se repetirán indefinidamente. Otros lenguajes de programación permiten esto a partir de sentencias del tipo "do" o "while", pero JALv2 posee una estructura especialmente creada para ello. Es posible salir de este loop, como veremos más adelante.

- LED1 = on es lo opuesto a "LED1 = off":  hace que la salida en la que está el led  se ponga en uno. JALv2 proporciona muchas formas equivalentes de decir "uno": on, high, 1 y true  son algunas de ellas.

-  delay_1ms(tiempo_encendido) utiliza la función "delay_1ms()" de la libreria "delay" para crear una demora de la cantidad de milisegundos que indica el valor de "tiempo_encendido" (en este caso 500, o lo que es lo mismo, medio segundo).

Este es el resultado:

Aprendiendo JALv2: Práctica 001

---

NOTA: Adjunto el programa fuente completo y el HEX listo para grabar.

---

Volver al índice

Una pequeña "evolución" del ejemplo anterior. Ahora tenemos dos LEDs encendiendo alternadamente. 


Esta es la parte más importante del programa:

-- Incluyo la librería que contiene las rutinas de demoras:
include delay

-- Configuro los pines de E/S------------------------------------------------
enable_digital_io()            -- Todos los pines configurados como E/S
alias LED1       is pin_b7     -- LED1 será equivalente al pin 40 (RB7)
alias LED2       is pin_b6     -- LED2 será equivalente al pin 39 (RB6)
pin_b7_direction = output      -- El pin que tiene el LED1 es una SALIDA
pin_b6_direction = output      -- El pin que tiene el LED2 es una SALIDA

LED1 = off                     -- Apago el LED1
LED2 = off                     -- Apago el LED2

-- Declaro las constantes y variables a utilizar en el programa -------------
const word tiempo  = 500       -- Milisegundos entre cambios.
-- --------------------------------------------------------------------------
-- Comienzo del bucle principal del programa 
-- --------------------------------------------------------------------------
forever loop  -- Bucle que se repite indefinidamente
   LED1 = on          --Enciendo el LED1...
   LED2 = off         --y apago el LED2.
   delay_1ms(tiempo)  --Espero el tiempo prefijado
   LED1 = off         --Apago el LED1...
   LED2 = on          --y enciendo el LED2.
   delay_1ms(tiempo)  --Espero el tiempo prefijado
end loop      -- Fin del bucle.

Como puede verse, el código es muy simple y está comentado. Si tienes alguna duda, utiliza el hilo especial para los comentarios y sugerencias

No hemos utilizado más instrucciones que las vistas en el ejemplo anterior, así que directamente te mostramos el resultado:

---

NOTA: Adjunto el programa fuente completo y el HEX listo para grabar.

---

Volver al índice

Este es el clásico efecto del punto luminoso que "va y viene", como el juego de luces que tenía el coche de la serie "El coche fantástico" en su frente. Esta es la forma de hacerlo "a lo bruto", controlando individualmente cada LED. Es posible hacerlo con las instrucciones vistas en los ejemplos anteriores. En el ejemplo siguiente veremos como hacer lo mismo de una forma mucho más eficiente.


Este es el código fuente del programa:

--------------------------------------------------------------------------------
--                Ejemplos de programación con JALv2
--
-- Ejemplo 003 c/PIC18F4550 y Multiboard PIC Trainer
-- Más detalles en http://www.ucontrol.com.ar/forosmf/jal-y-jalv2/
--------------------------------------------------------------------------------
-- Descripcion:
-- 8 LEDs en el portB realizan el típico movimiento del "coche fantástico"
-- sin sutilezas (ver ejemplo 004)
--
--------------------------------------------------------------------------------
-- Módulos utilizados:
--
-- Multiboard Pic Trainer 
-- (http://www.ucontrol.com.ar/forosmf/proyectos-con-pic/multiboard-pic-trainer-2-0/)
--
-- Módulo 8 E/S           
-- (http://www.ucontrol.com.ar/forosmf/circuiteca-la-biblioteca-de-circuitos-y-proyectos-de-ucontrol/pic-trainer/msg103/#msg103)
--
--------------------------------------------------------------------------------
-- Resumen uso E/S:
--
-- #Pin | Puerto | Función
--  ---------------------------------------------------------------------------
--  33  | RB0-RB7| Ochos LEDs, cada uno de ellos con el anodo conectado a uno de
--   a  |        | los pines del PIC y el cátodo a GND a través de una R de 220
--  40  | RB7    |  ohms.
--      |        |
--  ---------------------------------------------------------------------------- 
-- Oscilador con cristal de 20MHz
--------------------------------------------------------------------------------

-- Configuración de módulos del chip y fuses-----------------------------------
include 18f4550
pragma target clock       48_000_000

pragma target PLLDIV        P5          -- divide por 5 - 20MHZ_INPUT
pragma target CPUDIV        P2          -- OSC1_OSC2_SRC_1_96MHZ_PLL_SRC_2
pragma target USBPLL        F48MHZ      -- CLOCK_SRC_FROM_96MHZ_PLL_2
pragma target OSC           HS_PLL
pragma target FCMEN         DISABLED
pragma target IESO          DISABLED
pragma target PWRTE         DISABLED    -- power up timer
pragma target VREGEN        ENABLED     -- USB voltage regulator
pragma target VOLTAGE       V20         -- brown out voltage
pragma target BROWNOUT      DISABLED    -- no brownout detection
pragma target WDTPS         P32K        -- watch dog saler setting
pragma target WDT           DISABLED    -- no watchdog
pragma target CCP2MUX       pin_C1      -- CCP2 pin
pragma target PBADEN        DIGITAL     -- digital input port<0..4>
pragma target LPT1OSC       LOW_POWER   -- low power timer 1
pragma target MCLR          EXTERNAL    -- master reset on RE3
pragma target STVR          DISABLED    -- reset on stack over/under flow
pragma target LVP           DISABLED    -- no low-voltage programming
pragma target XINST         ENABLED     -- extended instruction set
pragma target DEBUG         DISABLED    -- background debugging
pragma target CP0           DISABLED    -- code block 0 not protected
pragma target CP1           DISABLED    -- code block 1 not protected
pragma target CP2           DISABLED    -- code block 2 not protected
pragma target CP3           DISABLED    -- code block 3 not protected
pragma target CPB           DISABLED    -- bootblock code not write protected
pragma target CPD           DISABLED    -- eeprom code not write protected
pragma target WRT0          DISABLED    -- table writeblock 0 not protected
pragma target WRT1          DISABLED    -- table write block 1 not protected
pragma target WRT2          DISABLED    -- table write block 2 not protected
pragma target WRT3          DISABLED    -- table write block 3 not protected
pragma target WRTB          DISABLED    -- bootblock not write protected
pragma target WRTD          DISABLED    -- eeprom not write protected
pragma target WRTC          DISABLED    -- config not write protected
pragma target EBTR0         DISABLED    -- table read block 0 not protected
pragma target EBTR1         DISABLED    -- table read block 1 not protected
pragma target EBTR2         DISABLED    -- table read block 2 not protected
pragma target EBTR3         DISABLED    -- table read block 3 not protected
pragma target EBTRB         DISABLED    -- boot block not protected

-- Incluyo la librería que contiene las rutinas de demoras:
include delay

-- Configuro los pines de E/S ------------------------------------------------
enable_digital_io()            -- Todos los pines configurados como E/S
alias LED0       is pin_b0     -- LED0  será equivalente a RB0
alias LED1       is pin_b1     -- LED1  será equivalente a RB1
alias LED2       is pin_b2     -- LED2  será equivalente a RB2
alias LED3       is pin_b3     -- LED3  será equivalente a RB3
alias LED4       is pin_b4     -- LED4  será equivalente a RB4
alias LED5       is pin_b5     -- LED5  será equivalente a RB5
alias LED6       is pin_b6     -- LED6  será equivalente a RB6
alias LED7       is pin_b7     -- LED7  será equivalente a RB7

PORTB_direction = 0x00         -- Todo el puerto B como salidas

LED0 = off                     -- Apago el LED0
LED1 = off                     -- Apago el LED1
LED2 = off                     -- Apago el LED2
LED3 = off                     -- Apago el LED3
LED4 = off                     -- Apago el LED4
LED5 = off                     -- Apago el LED5
LED6 = off                     -- Apago el LED6
LED7 = off                     -- Apago el LED7

-- Declaro las constantes y variables a utilizar en el programa -------------
const word tiempo  = 100       -- Milisegundos entre cambios.

-- --------------------------------------------------------------------------
-- Comienzo del bucle principal del programa 
-- --------------------------------------------------------------------------

forever loop  -- Bucle que se repite indefinidamente
LED0 = on          --Enciendo el LED0...
delay_1ms(tiempo)  --Espero el tiempo prefijado
LED0 = off         --Apago el LED0...
LED1 = on          --Enciendo el LED1...
delay_1ms(tiempo)  --Espero el tiempo prefijado
LED1 = off         --Apago el LED1...
LED2 = on          --y enciendo el LED2.
delay_1ms(tiempo)  --Espero el tiempo prefijadojado
LED2 = off         --Apago el LED2...
LED3 = on          --y enciendo el LED3.
delay_1ms(tiempo)  --Espero el tiempo prefijadojado
LED3 = off         --Apago el LED3...
LED4 = on          --y enciendo el LED4.
delay_1ms(tiempo)  --Espero el tiempo prefijado
LED4 = off         --Apago el LED4...
LED5 = on          --y enciendo el LED5.
delay_1ms(tiempo)  --Espero el tiempo prefijadojado
LED5 = off         --Apago el LED5...
LED6 = on          --y enciendo el LED6.
delay_1ms(tiempo)  --Espero el tiempo prefijadojado
LED6 = off         --Apago el LED6...
LED7 = on          --y enciendo el LED7.
delay_1ms(tiempo)  --Espero el tiempo prefijadojado
LED7 = off         --Apago el LED7...
--Aqui comienza la vuelta....
LED6 = on          --Enciendo el LED6...
delay_1ms(tiempo)  --Espero el tiempo prefijado
LED6 = off         --Apago el LED6...
LED5 = on          --y enciendo el LED5.
delay_1ms(tiempo)  --Espero el tiempo prefijadojado
LED5 = off         --Apago el LED5...
LED4 = on          --y enciendo el LED4.
delay_1ms(tiempo)  --Espero el tiempo prefijadojado
LED4 = off         --Apago el LED4...
LED3 = on          --y enciendo el LED3.
delay_1ms(tiempo)  --Espero el tiempo prefijado
LED3 = off         --Apago el LED3...
LED2 = on          --y enciendo el LED25.
delay_1ms(tiempo)  --Espero el tiempo prefijadojado
LED2 = off         --Apago el LED2...
LED1 = on          --y enciendo el LED1.
delay_1ms(tiempo)  --Espero el tiempo prefijadojado
LED1 = off         --Apago el LED1...
end loop      -- Fin del bucle.

-- Fin del programa



Este es el resultado:

---

NOTA: Adjunto el programa fuente completo y el HEX listo para grabar.

---

Volver al índice

Vamos aumentando un poco la dificultad con una aplicación interesante. El PWM se utiliza para muchas cosas, entre ellas controlar la velocidad de un motor de CC, dar efecto a luces de CC.


Código de programa.

Nota: Este programa, está en la carpeta de sample del JAL. Lo único que hice fue comentar, en castellano, el programa y doy una pequeña explicación.

-----------------------------------------------------------------
-- PWM CON UN LED
-----------------------------------------------------------------
--
-- El circuito está formado un cristal de 20Mhz
-- y un led en RC2
-----------------------------------------------------------------

-- Incluimos la librería del pic 16F877A
include 16f877a

pragma target clock 20_000_000                  -- xtal frequency
pragma target OSC        hs
pragma target   LVP disabled
pragma target   WDT disabled

-- COnfiguración de los pines.
alias lcd_bl is pin_c2
alias lcd_bl_direction is pin_c2_direction
   
enable_digital_io()

-- Configuracíon PWM
pin_ccp1_direction = output
include pwm_hardware
pwm_max_resolution(1)
pwm1_on()


forever loop
   
   var word i
   i = 0
   
   -- Resolución del PWM de 10 bit (duty < 1024)
   while i < 1020 loop -- Mientras i es menor a 1020
      pwm1_set_dutycycle_highres(i) -- cargamos el duty con el contenido de i
      _usec_delay(50000) -- Demora. Regulamos la velocidad del PWM
-- Si es muy chica la demora, no se apreciarán los cambios
-- Si es muy grande la demora, tardará mucho en ir de 0V a 5V
      i = i + 10 -- Incrementamos en 10 la variable i.
-- Modificando el incremento, también variamos la velocidad de barrido
-- del PWM
   end loop
   while i > 0 loop -- Aquí pasa lo mismo que el while anterior, pero en sentido inverso.
      pwm1_set_dutycycle_highres(i)
      _usec_delay(50000)
      i = i - 10
   end loop
   
   _usec_delay(50000) -- Tiempo de permanencia apagado el led una vez que terminó el ciclo anterior
   pwm1_off()
   _usec_delay(50000) -- Tiempo de permanencia encendido del led una vez que terminó el ciclo anterior
   pwm1_on()
    -- Si estos valores son chicos, o se anula esta parte del programa, el led variará
-- continuamente. Si es muy grande la demora, el led permanecera bastante tiempo
-- encendido y apagado hasta comenzar un nuevo ciclo del PWM
end loop

El resultado:

---

Volver al índice

Este es el clásico efecto del punto luminoso que "va y viene", como el juego de luces que tenía el coche de la serie "El coche fantástico" en su frente. Se ha implementado de una forma diferente a nuestro ejemplo 003 - 8 LEDs "Coche Fantástico" con PIC18F4550 (Versión 1), controlando todo el puerto B a la vez. Utilizamos algunas instrucciones nuevas, cuyo comportamiento explicamos luego de presentar el código fuente.


Este es el código fuente del programa:

--------------------------------------------------------------------------------
--                Ejemplos de programación con JALv2
--
-- Ejemplo 004 c/PIC18F4550 y Multiboard PIC Trainer
-- Más detalles en http://www.ucontrol.com.ar/forosmf/jal-y-jalv2/
--------------------------------------------------------------------------------
-- Descripcion:
-- 8 LEDs en el portB realizan el típico movimiento del "coche fantástico"
-- sin sutilezas (ver ejemplo 003)
--
--------------------------------------------------------------------------------
-- Módulos utilizados:
--
-- Multiboard Pic Trainer 
-- (http://www.ucontrol.com.ar/forosmf/proyectos-con-pic/multiboard-pic-trainer-2-0/)
--
-- Módulo 8 E/S           
-- (http://www.ucontrol.com.ar/forosmf/circuiteca-la-biblioteca-de-circuitos-y-proyectos-de-ucontrol/pic-trainer/msg103/#msg103)
--
--------------------------------------------------------------------------------
-- Resumen uso E/S:
--
-- #Pin | Puerto | Función
--  ---------------------------------------------------------------------------
--  33  | RB0-RB7| Ochos LEDs, cada uno de ellos con el anodo conectado a uno de
--   a  |        | los pines del PIC y el cátodo a GND a través de una R de 220
--  40  | RB7    |  ohms.
--      |        |
--  ---------------------------------------------------------------------------- 
-- Oscilador con cristal de 20MHz
--------------------------------------------------------------------------------

-- Configuración de módulos del chip y fuses-----------------------------------
include 18f4550
pragma target clock       48_000_000

pragma target PLLDIV        P5          -- divide por 5 - 20MHZ_INPUT
pragma target CPUDIV        P2          -- OSC1_OSC2_SRC_1_96MHZ_PLL_SRC_2
pragma target USBPLL        F48MHZ      -- CLOCK_SRC_FROM_96MHZ_PLL_2
pragma target OSC           HS_PLL
pragma target FCMEN         DISABLED
pragma target IESO          DISABLED
pragma target PWRTE         DISABLED    -- power up timer
pragma target VREGEN        ENABLED     -- USB voltage regulator
pragma target VOLTAGE       V20         -- brown out voltage
pragma target BROWNOUT      DISABLED    -- no brownout detection
pragma target WDTPS         P32K        -- watch dog saler setting
pragma target WDT           DISABLED    -- no watchdog
pragma target CCP2MUX       pin_C1      -- CCP2 pin
pragma target PBADEN        DIGITAL     -- digital input port<0..4>
pragma target LPT1OSC       LOW_POWER   -- low power timer 1
pragma target MCLR          EXTERNAL    -- master reset on RE3
pragma target STVR          DISABLED    -- reset on stack over/under flow
pragma target LVP           DISABLED    -- no low-voltage programming
pragma target XINST         ENABLED     -- extended instruction set
pragma target DEBUG         DISABLED    -- background debugging
pragma target CP0           DISABLED    -- code block 0 not protected
pragma target CP1           DISABLED    -- code block 1 not protected
pragma target CP2           DISABLED    -- code block 2 not protected
pragma target CP3           DISABLED    -- code block 3 not protected
pragma target CPB           DISABLED    -- bootblock code not write protected
pragma target CPD           DISABLED    -- eeprom code not write protected
pragma target WRT0          DISABLED    -- table writeblock 0 not protected
pragma target WRT1          DISABLED    -- table write block 1 not protected
pragma target WRT2          DISABLED    -- table write block 2 not protected
pragma target WRT3          DISABLED    -- table write block 3 not protected
pragma target WRTB          DISABLED    -- bootblock not write protected
pragma target WRTD          DISABLED    -- eeprom not write protected
pragma target WRTC          DISABLED    -- config not write protected
pragma target EBTR0         DISABLED    -- table read block 0 not protected
pragma target EBTR1         DISABLED    -- table read block 1 not protected
pragma target EBTR2         DISABLED    -- table read block 2 not protected
pragma target EBTR3         DISABLED    -- table read block 3 not protected
pragma target EBTRB         DISABLED    -- boot block not protected

-- Incluyo la librería que contiene las rutinas de demoras:
include delay

-- Configuro los pines de E/S ------------------------------------------------
enable_digital_io()            -- Todos los pines configurados como E/S
portb_direction = 0x00         -- Todo el puerto B como salidas
portb = 0x01                   -- Apago todo el puerto menos el bit 1

-- Declaro las constantes y variables a utilizar en el programa -------------
const word tiempo  = 60       -- Milisegundos entre cambios.
var   byte i       = 0         -- Variable auxiliar para el bucle "for"
-- --------------------------------------------------------------------------
-- Comienzo del bucle principal del programa 
-- --------------------------------------------------------------------------

forever loop  -- Bucle que se repite indefinidamente
--delay_1ms(tiempo)  --Espero el tiempo prefijado
        for 7 loop
                portb = portb * 2 
       delay_1ms(tiempo)  --Espero el tiempo prefijado
        end loop
        -- Ahora, la vuelta...
        for 7 loop
               portb = portb / 2 
       delay_1ms(tiempo)  --Espero el tiempo prefijado
        end loop
end loop      -- Fin del bucle.

-- Fin del programa


Veamos cuales son las instrucciones u ordenes nuevas que hemos utilizado esta vez, y cual es su utilidad dentro del programa:

- portb_direction = 0x00 hace que todo el puerto B quede configurado como salidas. El valor "0x00" es el responsable de esto. Si se quiere configurar con alguna combinacion en particular de pines como entrada y como salida, solo debes recordar que "0" es salida y "1" es entrada.

- portb = 0x01  pone todos los pines del puerto B en cero (leds apagados),  menos el bit 1, por lo que ese led queda encendido.

- var   byte i       = 0  declara la variable "i" como tipo "byte" y le asigna el valor 0.

- for 7 loop ... end loop es similar a la estructura "forever loop....end loop", con la diferencia que en lugar de repetirse indefinidamente solo lo hace siete veces.

- portb = portb * 2 simplimiente multiplica el valor del portb por dos. Dado que su valor inicial es 1 (00000001), va a ir tomando los valores 2 (00000010),  4 (00000100), 8 (00001000), etc, hasta 128 (10000000). Dado que tenemos un led en cada salida, el efecto es que los leds se van encendiendo en secuencia, de derecha a izquierda, tal como necesitabamos.

- portb = portb / 2  hace lo opuesto a la sentencia anterior: divide el valor del puerto b por 2, siete veces. Eso hace que el "1" se desplace desde la izquierda hasta la derecha.  Bueno, bonito y barato


Este es el resultado:

---

NOTA: Adjunto el programa fuente completo y el HEX listo para grabar.

---

Volver al índice

Este programa, es una modificación del anterior (PWM). Se le agregaron dos pulsadores el cual, el pulsador 1 selecciona el efecto 1 y el pulsador 2, selecciona el efecto 2. Una segunda pulsación del mismo pulsador, apaga el LED.


El código o firmware.


-----------------------------------------------------------------
-- PWM CON UN LED Y 2 PULSADORES PARA CAMBIAR 2 DIFERENTES EFECTOS
-----------------------------------------------------------------
--
-- El circuito está formado un cristal de 20Mhz
-- y un led en RC2
-----------------------------------------------------------------

-- Incluimos la librería del pic 16F877A
include 16f877a

pragma target clock 20_000_000                  -- xtal frequency
pragma target OSC        hs
pragma target   LVP disabled
pragma target   WDT disabled

-- COnfiguración de los pines.
alias lcd_bl is pin_c2
alias lcd_bl_direction is pin_c2_direction
alias pulsador1 is pin_c0
alias pulsador2 is pin_c1
alias pulsador1_direction is pin_c0_direction
alias pulsador2_direction is pin_c1_direction
alias pulsador3_direction is pin_c3_direction
   
enable_digital_io()

-- Configuracíon PWM
pin_ccp1_direction = output
pulsador1 = input
pulsador2 = input
include pwm_hardware
pwm_max_resolution(1)
pwm1_on()

var word pulsador

forever loop
var dword b
b = 0
while b < 0xFFFF loop -- Realizamos una pequeña demora para escanear el teclado. Aproximadamente medio segundo
if pulsador1 != 0 then -- Corriendo a 20Mhz
if pulsador == 1 then -- Escaneamos el teclado. Si el pulsador en C0 es 1, y si la variable pulsador es igual a 1
pulsador = 0 -- Lo colocamos en 0
else -- En cambio
pulsador = 1 -- Lo ponemos es 1.
end if -- Lo que logramos aquí, es que con el mismo pulsador prendemos o apagamos el efecto elegido
end if

if pulsador2 != 0 then -- Idem anterior pero con el pulsador conectado a C1.
if pulsador == 2 then
pulsador = 0
else
pulsador = 2
end if
end if
b = b + 1
end loop
   
   var word i
   i = 0
pwm1_on()
   
---------------------------------------------------------------------------------
-- Primer efecto. Se elige con el pulsador 1
---------------------------------------------------------------------------------
if pulsador == 1 then

   -- Resolución del PWM de 10 bit (duty < 1024)
  while i < 1020 loop -- Mientras i es menor a 1020
     pwm1_set_dutycycle_highres(i) -- cargamos el duty con el contenido de i
     _usec_delay(50000) -- Demora. Regulamos la velocidad del PWM
-- Si es muy chica la demora, no se apreciarán los cambios
-- Si es muy grande la demora, tardará mucho en ir de 0V a 5V
      i = i + 10 -- Incrementamos en 10 la variable i.
-- Modificando el incremento, también variamos la velocidad de barrido
-- del PWM
    end loop -- Sale del While cuando i = a 1020, mientras sea menor, se repite el while.
    while i > 0 loop -- Aquí pasa lo mismo que el while anterior, pero en sentido inverso.
    pwm1_set_dutycycle_highres(i) -- Recordemos que en este punto i = 1020
      _usec_delay(50000)
      i = i - 10
    end loop
   
  _usec_delay(50000) -- Tiempo de permanencia apagado el led una vez que terminó el ciclo anterior
    pwm1_off()
    _usec_delay(50000) -- Tiempo de permanencia encendido del led una vez que terminó el ciclo anterior
    pwm1_on()
    -- Si estos valores son chicos, o se anula esta parte del programa, el led variará
-- continuamente. Si es muy grande la demora, el led permanecera bastante tiempo
end if -- encendido y apagado hasta comenzar un nuevo ciclo del PWM

---------------------------------------------------------------------------------
-- Segundo efecto. Se elige con el pulsador 2
---------------------------------------------------------------------------------
if pulsador == 2 then
while i < 1020 loop
pwm1_set_dutycycle_highres(i) -- Noten que la única diferencia en esta rutina de PWM
_usec_delay(10000) -- Cambia los valores de demora
i = i + 20 -- y la incrementación de los valores para el PWM
end loop
_usec_delay(1000)
pwm1_off()
end if
if pulsador == 0 then
pwm1_off()
end if

end loop

Veamos las instrucciones nuevas que hemos utilizado aquí:

if pulsador1 != 0 then            
         if pulsador == 1 then         -- Si el pulsador en C0 es 1, y si la variable pulsador es igual a 1
            pulsador = 0            -- Lo colocamos en 0
         else                     -- En cambio
            pulsador = 1            -- Lo ponemos es 1.
         end if                     -- Lo que logramos aquí, es que con el mismo pulsador prendemos o apagamos el efecto elegido
      end if

Este se lo conoce como Toggle. Lo que hace es, leer el estado del pulsador1 para ver si se pulsó. En caso negativo, sale del IF sin hacer nada, pero si es afirmativo (la pulsación) lee el valor en pulsador para cambiarle por el valor opuesto en el bit 0.
La variable pulsador, al ser de tipo word, está compuesto por 8 bit enumerados del 0 al 7.

1 en binario es 00000001
0 en binario es 00000000

while b < 0xFFFF loop

Lo que hace, es permanecer dentro del while hasta que b sea igual o mayor a 0xFFFF. La condición dice que, mientras b sea menor a 0xFFFF te mantenés aquí. Como deducción, cuando b sea igual o mayor a 0xFFFF dejará de cumplir dicha condición y saldrá del while (mientras)

El resultado:


Adjuntado está el hex y el programa.

---

Volver al índice

Utilizar con JALv2 un display alfanumérico -de cualquier tamaño- es muy fácil. Basta con elegir 6 pines cualesquiera del micro para conectar el LCD (RS, E, D4,D5,D6 y D7) -o 10 si queremos una conexión de 8 bits), configurarlos adecuadamente, y enviar el texto que se quiere mostrar.


En este primer ejemplo veremos como incluir la librería correspondiente, declarar los pines involucrados (en modo 4 bits de datos) y mostrar cadenas de texto en el LCD.

Este es el código fuente del programa:

-- Configuración de módulos del chip y fuses-----------------------------------
include 18f4550
pragma target clock       48_000_000

pragma target PLLDIV        P5          -- divide por 5 - 20MHZ_INPUT
pragma target CPUDIV        P2          -- OSC1_OSC2_SRC_1_96MHZ_PLL_SRC_2
pragma target USBPLL        F48MHZ      -- CLOCK_SRC_FROM_96MHZ_PLL_2
pragma target OSC           HS_PLL
pragma target FCMEN         DISABLED
pragma target IESO          DISABLED
pragma target PWRTE         DISABLED    -- power up timer
pragma target VREGEN        ENABLED     -- USB voltage regulator
pragma target VOLTAGE       V20         -- brown out voltage
pragma target BROWNOUT      DISABLED    -- no brownout detection
pragma target WDTPS         P32K        -- watch dog saler setting
pragma target WDT           DISABLED    -- no watchdog
pragma target CCP2MUX       pin_C1      -- CCP2 pin
pragma target PBADEN        DIGITAL     -- digital input port<0..4>
pragma target LPT1OSC       LOW_POWER   -- low power timer 1
pragma target MCLR          EXTERNAL    -- master reset on RE3
pragma target STVR          DISABLED    -- reset on stack over/under flow
pragma target LVP           DISABLED    -- no low-voltage programming
pragma target XINST         ENABLED     -- extended instruction set
pragma target DEBUG         DISABLED    -- background debugging
pragma target CP0           DISABLED    -- code block 0 not protected
pragma target CP1           DISABLED    -- code block 1 not protected
pragma target CP2           DISABLED    -- code block 2 not protected
pragma target CP3           DISABLED    -- code block 3 not protected
pragma target CPB           DISABLED    -- bootblock code not write protected
pragma target CPD           DISABLED    -- eeprom code not write protected
pragma target WRT0          DISABLED    -- table writeblock 0 not protected
pragma target WRT1          DISABLED    -- table write block 1 not protected
pragma target WRT2          DISABLED    -- table write block 2 not protected
pragma target WRT3          DISABLED    -- table write block 3 not protected
pragma target WRTB          DISABLED    -- bootblock not write protected
pragma target WRTD          DISABLED    -- eeprom not write protected
pragma target WRTC          DISABLED    -- config not write protected
pragma target EBTR0         DISABLED    -- table read block 0 not protected
pragma target EBTR1         DISABLED    -- table read block 1 not protected
pragma target EBTR2         DISABLED    -- table read block 2 not protected
pragma target EBTR3         DISABLED    -- table read block 3 not protected
pragma target EBTRB         DISABLED    -- boot block not protected

-- Incluyo la librería que contiene las rutinas de demoras:
include delay

-- Configuro los pines de E/S ------------------------------------------------
enable_digital_io()            -- Todos los pines como I/O digitales
-- Declaro las constantes y variables a utilizar en el programa -------------
portb_direction = 0x00         -- Todo el puerto B como salidas
portb = 0x01                   -- Apago todo el puerto menos el bit 1
                              -- Pin usado como test - se puede obviar.

var   byte i       = 0         -- Variable auxiliar para el bucle "for"
-- Defino todo lo relacionado con el LCD
const byte LCD_ROWS    =  4           -- LCD de 4 lineas
const byte LCD_CHARS   =  20          -- y 20 caracteres por linea

alias  lcd_en        is  pin_D2       -- Pin E del LCD
alias  lcd_rs        is  pin_D1       -- Pin RS del LCD
alias  lcd_dataport  is  portD_high   -- 4 data pins
portD_direction   = all_output        -- Todo el puerto D como salidas

-- Cadenas a mostrar:
var byte line1[LCD_CHARS] = "PRACTICAS CON JAL v2"
var byte line2[LCD_CHARS] = "LCD alfanum. de 4x20"
var byte line3[LCD_CHARS] = "--------------------"
var byte line4[LCD_CHARS] = "www.ucontrol.com.ar "

-- --------------------------------------------------------------------------
-- Incluyo librerias e inicializo LCD:
-- --------------------------------------------------------------------------
include lcd_hd44780_4                 -- Incluyo la libreria del LCD
lcd_init()                            -- e inicializo el controlador del LCD

-------------------------------------------------------------------------------
-- Comienza el programa en si
-------------------------------------------------------------------------------
lcd_clear_screen() -- Limpio la pantalla
for LCD_CHARS using i loop
lcd_cursor_position(0,i) --Coloco el cursor en su sitio...
lcd_write_char(line1[i]) --y muestro el caracter correspondiente
lcd_cursor_position(1,i) --Idem, segunda linea
lcd_write_char(line2[i])   
lcd_cursor_position(2,i) --Idem, tercera linea
lcd_write_char(line3[i])   
lcd_cursor_position(3,i) --Idem, cuarta linea
lcd_write_char(line4[i])   
end loop

-- Fin del programa


Veamos cuales son las instrucciones u ordenes nuevas que hemos utilizado esta vez, y cual es su utilidad dentro del programa:

- Las lineas
const byte LCD_ROWS    =  4           -- LCD de 4 lineas
const byte LCD_CHARS   =  20          -- y 20 caracteres por linea

definen las dimensiones de nuestro LCD alfanumérico. Puede ser de una a 4 lineas, de 8 a 40 columnas.

- Las lineas siguientes:
alias  lcd_en        is  pin_D2       -- Pin E del LCD
alias  lcd_rs        is  pin_D1       -- Pin RS del LCD
alias  lcd_dataport  is  portD_high   -- 4 data pins
portD_direction   = all_output        -- Todo el puerto D como salidas
definen que pines controlan el LCD. En este caso, todos pertenecen al puerto D, que ha sido definido completamente como salidas. Los cuatro pines de datos son D4,D5,D6 y D7, que como representan la mitad superior del puerto, se declara con "lcd_dataport  is  portD_high". Después veremos que pueden utilizarse 4 pines cualquiera para ello, definiéndolos uno por uno.

- include lcd_hd44780_4 incluye en nuestro proyecto la libreria correspondiente al control del LCd en modo 4 bits.

- Asi asignamos las cadenas de cada linea:
var byte line1[LCD_CHARS] = "PRACTICAS CON JAL v2"
var byte line2[LCD_CHARS] = "LCD alfanum. de 4x20"
var byte line3[LCD_CHARS] = "--------------------"
var byte line4[LCD_CHARS] = "www.ucontrol.com.ar "

- lcd_init()   inicializa el LCD.

- lcd_clear_screen() borra completamente la plantalla.

- Finalmente, el bucle siguiente muestra los caracteres en la pantalla. Notesé la instrucción     lcd_cursor_position(x,y) que mueve el cursos a la posición deseada, y lcd_write_char(x)  que escribe un caracter en la posición que se encuentra el cursor.

for LCD_CHARS using i loop
lcd_cursor_position(0,i) --Coloco el cursor en su sitio...
lcd_write_char(line1[i]) --y muestro el caracter correspondiente
lcd_cursor_position(1,i) --Idem, segunda linea
lcd_write_char(line2[i])   
lcd_cursor_position(2,i) --Idem, tercera linea
lcd_write_char(line3[i])   
lcd_cursor_position(3,i) --Idem, cuarta linea
lcd_write_char(line4[i])   
end loop

Este es el resultado:

---

NOTA: Adjunto el programa fuente completo y el HEX listo para grabar.

---

Volver al índice

Utilizar con JALv2 un display alfanumérico -de cualquier tamaño- es muy fácil. Ya vimos como hacerlo en un ejemplo anterior, pero ahora, vamos a ver como utilizar la librería "print.jal" para mostrar valores numéricos en cualquier base y cadenas de texto.


En este segundo ejemplo incluir la librería correspondiente, declarar los pines involucrados (en modo 4 bits de datos) y mostrar cadenas de texto en el LCD.

Este es el código fuente del programa:


-- Configuración de módulos del chip y fuses-----------------------------------
include 18f4550
pragma target clock       48_000_000

pragma target PLLDIV        P5          -- divide por 5 - 20MHZ_INPUT
pragma target CPUDIV        P2          -- OSC1_OSC2_SRC_1_96MHZ_PLL_SRC_2
pragma target USBPLL        F48MHZ      -- CLOCK_SRC_FROM_96MHZ_PLL_2
pragma target OSC           HS_PLL
pragma target FCMEN         DISABLED
pragma target IESO          DISABLED
pragma target PWRTE         DISABLED    -- power up timer
pragma target VREGEN        ENABLED     -- USB voltage regulator
pragma target VOLTAGE       V20         -- brown out voltage
pragma target BROWNOUT      DISABLED    -- no brownout detection
pragma target WDTPS         P32K        -- watch dog saler setting
pragma target WDT           DISABLED    -- no watchdog
pragma target CCP2MUX       pin_C1      -- CCP2 pin
pragma target PBADEN        DIGITAL     -- digital input port<0..4>
pragma target LPT1OSC       LOW_POWER   -- low power timer 1
pragma target MCLR          EXTERNAL    -- master reset on RE3
pragma target STVR          DISABLED    -- reset on stack over/under flow
pragma target LVP           DISABLED    -- no low-voltage programming
pragma target XINST         ENABLED     -- extended instruction set
pragma target DEBUG         DISABLED    -- background debugging
pragma target CP0           DISABLED    -- code block 0 not protected
pragma target CP1           DISABLED    -- code block 1 not protected
pragma target CP2           DISABLED    -- code block 2 not protected
pragma target CP3           DISABLED    -- code block 3 not protected
pragma target CPB           DISABLED    -- bootblock code not write protected
pragma target CPD           DISABLED    -- eeprom code not write protected
pragma target WRT0          DISABLED    -- table writeblock 0 not protected
pragma target WRT1          DISABLED    -- table write block 1 not protected
pragma target WRT2          DISABLED    -- table write block 2 not protected
pragma target WRT3          DISABLED    -- table write block 3 not protected
pragma target WRTB          DISABLED    -- bootblock not write protected
pragma target WRTD          DISABLED    -- eeprom not write protected
pragma target WRTC          DISABLED    -- config not write protected
pragma target EBTR0         DISABLED    -- table read block 0 not protected
pragma target EBTR1         DISABLED    -- table read block 1 not protected
pragma target EBTR2         DISABLED    -- table read block 2 not protected
pragma target EBTR3         DISABLED    -- table read block 3 not protected
pragma target EBTRB         DISABLED    -- boot block not protected


-- Configuro los pines de E/S --------------------------------------------------
enable_digital_io()                     -- Todos los pines como I/O digitales

--Constantes a utilizar en el programa -----------------------------------------
const byte   LCD_ROWS           =  4    -- LCD de 4 lineas
const byte   LCD_CHARS          =  20   -- y 20 caracteres por linea

-- Variables a utilizar en el programa -----------------------------------------
var   byte i           = 0              -- Variables auxiliares para bucles

-- Defino E/S relacionadas con el LCD
alias  lcd_en        is  pin_D2         -- Pin E del LCD
alias  lcd_rs        is  pin_D1         -- Pin RS del LCD
alias  lcd_dataport  is  portD_high     -- 4 data pins
portD_direction   = all_output          -- Todo el puerto D como salidas
-- ...y lo inicializo:
include lcd_hd44780_4                   -- Incluyo la libreria del LCD
lcd_init()                              -- e inicializo su controlador

-- Cadenas a mostrar:       
var byte line1[LCD_CHARS] = "Probando libreria de"
var byte line2[LCD_CHARS] = "JALv2  ( print.jal )"
var byte line3[LCD_CHARS] = "www.ucontrol.com.ar "
var byte line4[LCD_CHARS] = "Visualiza numeros en"
var byte line5[LCD_CHARS] = "    Decimal:        "
var byte line6[LCD_CHARS] = "Hexadecimal:        "
var byte line7[LCD_CHARS] = "    Binario:        "
var byte line8[LCD_CHARS] = "Eso a sido todo.  :)"

--------------------------------------------------------------------------------
-- Incluyo librerías:
--------------------------------------------------------------------------------
include delay                       -- Rutinas de demoras:
include print                       -- Rutinas para mostrar valores en LCD

-------------------------------------------------------------------------------
-- Comienza el programa en si
-------------------------------------------------------------------------------
forever loop --Bucle principal -------------------------------------------------
    lcd_clear_screen()                  -- Borro la pantalla

    ------------------------ Pantalla de bienvenida --------------------
    lcd_cursor_position(0,0)      --Coloco el cursor en su sitio...
    print_string(lcd, line1)      --y linea correspondiente
    lcd_cursor_position(1,0)      --Coloco el cursor en su sitio...
    print_string(lcd, line2)      --y linea correspondiente
    lcd_cursor_position(3,0)      --Coloco el cursor en su sitio...
    print_string(lcd, line3)      --y linea correspondiente

    delay_100ms(50)               --Espero cinco segundos...

    ------------------------ Pantalla de "trabajo"  --------------------
    lcd_clear_screen()            -- Borro la pantalla

    lcd_cursor_position(0,0)      --Coloco el cursor en su sitio...
    print_string(lcd, line4)      --y linea correspondiente
    lcd_cursor_position(1,0)      --Coloco el cursor en su sitio...
    print_string(lcd, line5)      --y linea correspondiente
    lcd_cursor_position(2,0)      --Coloco el cursor en su sitio...
    print_string(lcd, line6)      --y linea correspondiente
    lcd_cursor_position(3,0)      --Coloco el cursor en su sitio...
    print_string(lcd, line7)      --y linea correspondiente
   
    -- y recorro un bucle de 0 a 255, mostrando los valores en tres
    -- bases diferentes (decimal, hexadecimal y binario).

    for 255 using i loop
       lcd_cursor_position(1,12)  --Coloco el cursor en su sitio...
       print_word_dec(lcd, i)     --y muestro el valor en decimal.
       lcd_cursor_position(2,12)  --Coloco el cursor en su sitio...
       print_byte_hex(lcd, i)     --y muestro el valor en hexadecimal.   
       lcd_cursor_position(3,12)  --Coloco el cursor en su sitio...
       print_byte_binary(lcd, i)  --y muestro el valor en binario.   
       delay_100ms(10-(i/30))     --Espero antes de pasar al siguiente....
    end loop

    delay_100ms(20)               --Espero dos segundos...

    ------------------------ Pantalla final -------------------------
    lcd_clear_screen()            -- Borro la pantalla

    lcd_cursor_position(0,0)      --Coloco el cursor en su sitio...
    print_string(lcd, line1)      --y linea correspondiente
    lcd_cursor_position(1,0)      --Coloco el cursor en su sitio...
    print_string(lcd, line2)      --y linea correspondiente
    lcd_cursor_position(2,0)      --Coloco el cursor en su sitio...
    print_string(lcd, line3)      --y linea correspondiente
    lcd_cursor_position(3,0)      --Coloco el cursor en su sitio...
    print_string(lcd, line8)      --y linea correspondiente

    delay_100ms(50)               --Espero cinco segundos...
end loop


Veamos cuales son las instrucciones u ordenes nuevas que hemos utilizado esta vez, y cual es su utilidad dentro del programa:

- Definimos las cadenas que queremos mostrar:
-- Cadenas a mostrar:       
var byte line1[LCD_CHARS] = "Probando libreria de"
var byte line2[LCD_CHARS] = "JALv2  ( print.jal )"
var byte line3[LCD_CHARS] = "www.ucontrol.com.ar "
var byte line4[LCD_CHARS] = "Visualiza numeros en"
var byte line5[LCD_CHARS] = "    Decimal:        "
var byte line6[LCD_CHARS] = "Hexadecimal:        "
var byte line7[LCD_CHARS] = "    Binario:        "
var byte line8[LCD_CHARS] = "Eso a sido todo.  :)"

- Incluimos las librerias necesarias. La segunda es la que gestiona la impresion en el LCD (y tambien en el puerto serie, como vermos más adelante)

--------------------------------------------------------------------------------
-- Incluyo librerías:
--------------------------------------------------------------------------------
include delay                       -- Rutinas de demoras:
include print                       -- Rutinas para mostrar valores en LCD

- print_string(lcd, line1) muestra el contenido del arreglo line1 a partir de la posición actual del cursor.

- print_word_dec(lcd, i) imprime el valor de la variable i en formato decimal, partir de la posición actual del cursor.

- print_byte_hex(lcd, i) imprime el valor de la variable i en formato hexadecimal, partir de la posición actual del cursor.

- print_byte_binary(lcd, i) imprime el valor de la variable i en formato binario, partir de la posición actual del cursor.

No hay más que eso. Con un puñado de instrucciones nuevas podemos gestionar perfectamente la impresion de variables y cadenas en un display LCD alfanumérico. Este es el resultado:

---

NOTA: Adjunto el programa fuente completo y el HEX listo para grabar.

---

Volver al índice

Hola a todos!!

Como lo prometì subo el programita. 
En èl encontraremos los ejemplos publicados, màs algunas variantes creadas por mi


               Ejemplos JAL

Seguramente se podrà modificar a gusto para otras aplicaciones y màs que seguro mejorar. 

Espero haber interpretado correctamente los ejemplos de uds. , y si hay algo mal por favor corrijanme

Les adjunto los archivos para que analicen el còdigo

  Gracias por enseñar! 

Les muestro el circuito que utilicè para diseñar el programa



Tambièn algunas fotos de mi entorno de desarrollo, al que llamo Pic Vali Trainer (cuando las vean entenderàn porque le puse asì)








Por ùltimo la direcciòn donde tomar los datos del ULN 2803

         http://www.datasheetcatalog.org/datasheets/90/366828_DS.pdf

Pruebas con el ADC y Jal
En èsta oportunidàd tenemos un programa que muestra en un LCD 2 x 20 el valor del escalon correspondiente a la conversiòn y simultàneamente, el valor de tensiòn presente en la entrada del ADC
Lo contrastamos con un tester, y vemos el resultado.
El tester està colocado directemente sobre la entrada AN0 de un Pic 16F877a y masa.
El display tiene solo 4 lìneas de datos y la base de tiempo està dada por un cristal de solo 4 Mhz.
Un dato curioso es que mi tester, sin que estè alimentado el Pic, mide 000, pero en cuanto se conecta la alimentaciòn, sube a 0,02 volts.
Para que el arrastre sea lo màs parejo posible, al valor de la mediciòn le agrego 2 . (se puede descartar, pero la diferencia a lo largo de la mediciòn serìa importante).
Se debe tener en cuenta que la velocidad de respuesta de los dos instrumentos es muy diferente, y que el Pic trabaja con el ADC a 8 bits.
Le agrego decimales para simular la mediciòn como el tester, de una manera poco pràctica, pero funciona......

                              Asì se ve:
                                        Medicion de voltaje con Jal

   Y èste es el circuito utilizado y el programa completo:

---

Volver al índice

---

Acà les adjunto el circuito en : jpg para los que no tengan Proteus

---

Editado para ver la imagen directamente.
HJ

En èsta oportunidàd, ampliaremos el ejemplo anterior del voltìmetro en Jal.
Agregamos una pantalla de inicio con mensaje mòvil, escribiendo cada palabra desde los laterales correspondientes. Luego, las mìsmas palabras las escribimos alternadamente letra por letra, tambièn desde los laterales.
El efecto està bueno y està realizado de una manera muy simple, no se utilizan algoritmos, y si se dispone de suficiente memoria en el micro, se puede usar sin problemas, luego lo haremos de una manera màs tecnica.
Aplicaremos una rutina de promedio para el ADC, que se puede modificar segùn las necesidades en cuanto a la cantidàd de muestras.
Y por ùltimo, manejaremos la EEPROM en una forma interesante, no por el manejo de la misma, porque es tan simple en èste lenguaje que da verguenza, sino por la aplicaciòn: convertiremos al simple voltìmetro en un indicador de voltaje màximo, guardando los datos en la memoria y mostràndolos simultàneamente con la mediciòn de voltaje actual, cada vez que el voltaje supere al memorizado, se mostraràn los dos iguales porque siempre serà mayor a la anterior (escribirà y leerà el valor para pasarlo al LCD mientras se cumpla èsta condiciòn).
En cambio, si el voltaje disminuye, la EEPROM entregarà el ùltimo valor màximo registrado.

                                 Y èste es el resultado:
                           ADC LCD y EEPROM

Recordemos que està realizado con un Pic 16F877a y corriendo con un cristal de 4 Mhz.
El display es un Fordata 2x20 de tamaño grande, compatible con la librerìa de Jal.
El circuito utilizado es el mìsmo del ejemplo anterior, por lo tanto no lo incluyo


                                    Acà estàn los archivos de programa completos