Ejercicios en C con un QY4

[RICHI777]

Hola a todos, muy buenos ejemplos Geo ! Excelentemente escrito ! un buen programa en "C" con solo mirarlo tiene que entenderse que hace y solo unos pocos comentarios !!!
Lo único y muy importante para corregir es el tipo de datos, en algun lugar hace uso de variables tipo "int", hay que recordar que esta arquitectura es de 8 bits, y simular un entero de 16 bits con signo al pobre micrito le cuesta un huevo. Podes verlo vos mismo con un ejemplo tirando un dissambler en operaciones que utilizan enteros con signo y sin signo, vos mismo notaras las diferencias.
Otra cosa, que es muy utilzada tanto en lo visual y lo conceptual es utilizar typedefs, como si fuera Pascal. Ejemplo:
typedef unsigned char byte;
typedef unsigned short int word;
typedef unsigned long dword;

Hay mas...los programas asi quedan mas claros !
Saludos !

[RICHI777]

Bueno lo que dije en el post anterior si bien es una buena practica de codificacion, en el caso del HC(S)08 y FreeScale poco importa, ya que el micro tiene un par de intrucciones para el manejo de un entero de 16 bits signeado ( H:X ) y el compilador se las arregla para dejar el codigo lo mas optimo posibe, en mi vida vi muchos compiladores pero este se zarpa de lo bueno que es.
Salu2!

[Micro23]

Te Felicito por tus aportes Geo!  Encontre algunos codigos de ejemplo para el CodeWarrior en este link
Si suben algunas carpetas encontraran info interesante.
Saludos.

[LABmouse]

Geo muchisimas gracias por los aportes, ahora que estoy entrando de elleno en el mundo de los DSPs y MCUs freescale me estan sirviendo muchisimo tus programas..

SALUDOS!!

[scientist]

hola geo, muy buenos aportes, por circunstancias del destino ha caido en mis manos una tarjeta igualita a la tuya, en el disco de instalacion, me vino la version del codewarrior v 3.1, ahora he estado jugando con el codewarrior, pero no logra dar con las opciones antes de entrar a al programa en c, digo, no seria mucho pedir que hicieras algo asi como una iniciacion, no importa con cual version, pero si para poder empezar a trabajar, estoy algo atascado aqui, nunca he trabajado con la familia de 8 bits de freescale, y me estoy dando de topes, gracias

[Geo]

Tengo otros programas de prueba que había olvidado subir, perdonen el descuido pero en ocasiones olvido algunas cosas, el próximo fin me pongo a mano .

[scientist]

muchas gracias Geo, me ha estado dando lata el ADC, no he podido hacer que funcione con el oscilador interno, no se a  que se deba, ya que configura a mi entender bien los registros de ADCLK, ADSCR, pero nada de nada,si puedes subir un ejemplo muy facil con el qy4, estare muy agradecido

[Geo]

muchas gracias Geo, me ha estado dando lata el ADC, no he podido hacer que funcione con el oscilador interno, no se a  que se deba, ya que configura a mi entender bien los registros de ADCLK, ADSCR, pero nada de nada,si puedes subir un ejemplo muy facil con el qy4, estare muy agradecido

Ahorita voy a poner unas variaciones del multiplicador de 4 bits, luego pongo un voltímetro, espero que te sirva ese .

Multiplicador 4 bits (2)

Multiplicador

Código: C

1. /*********************************************
2.  * Multiplicador 4 bits.
3.  * Multiplica un par de datos de 4 bits.
4.  * Esta versión da el resultado en forma serie
5.  * en dos líneas, una llama a la interrupción
6.  * IRQ2 de un segundo microcontrolador indicando
7.  * que se enviará un bit, y en la otra se coloca
8.  * el valor del bit.
9.  *********************************************/
10.  
11. #include <MC68HC908QY4.h>   // Se definen los registros de I/O y sus direcciones.
12. #include <hidef.h>         // Contiene instrucciones en ensamblador.
13. #include <startup.h>
14.  
15. void inicializacion( void );
16. void delay( unsigned int );
17.  
18. int dato_a = 0;
19. int dato_b = 0;
20. int resultado;
21. int aux_a = -1;
22. int aux_b = -1;
23.  
24. /* ----------------------------
25.  * Entradas *
26.  * -------- *
27.  * PTB7 - PTB5: Dato A (4 bits)
28.  * PTB4 - PTB0: Dato B (4 bits)
29.  * ----------------------------
30.  * Salidas *
31.  * ------- *
32.  * PTA0: Salida de datos
33.  * PTA1: Sincronización
34.  * PTA3: Reset comunicación
35.  * ----------------------------
36.  */
37.  
38. void main( void ) {
39.    int i;
40.    
41.    inicializacion();
42.    
43.    while( 1 ) {
44.       dato_a = ( PTB >> 4 );
45.       dato_b = ( PTB & 0x0F );
46.      
47.       // Si los datos han cambiado.
48.       if ( ( aux_a != dato_a ) || ( aux_b != dato_b ) ) {
49.          // Multiplica
50.          resultado = dato_a * dato_b;
51. //         resultado = 15;
52.          // Actualiza auxiliares
53.          aux_a = dato_a; aux_b = dato_b;
54.          
55.          PTA_PTA3 = 1;
56.          PTA_PTA1 = 1;
57.          delay( 10000 );
58.          PTA_PTA3 = 0;
59.          PTA_PTA0 = 0;
60.          // Envío de datos
61.          for ( i = 7; i >= 0; i-- ) {
62.             PTA_PTA1 = 1;
63.             delay( 10000 );
64.             // Coloca el dato
65.             PTA_PTA0 = ( resultado >> i );
66.             delay( 10000 );
67.             // Indica que el dato está listo
68.             PTA_PTA1 = 0;
69.             // Espera un tiempo.
70.             delay( 10000 );
71.             PTA_PTA1 = 1;
72.             delay( 20000 );
73.          }
74.          PTA_PTA1 = 0;
75.       }
76.    }
77. }
78.  
79.  
80. void inicializacion() {
81.    CONFIG1 = 0x09;   // Deshabilita el perro guardián
82.    OSCTRIM = 0x80;   // Registro de ajuste de oscilador interno
83.    PTBPUE  = 0xFF;   // Resistencias de pull-up para el puerto B (todos los pines).
84.    PTAPUE  = 0x04;   // Resistencia de pull-up para el puerto A (solamente el pin PTA2).
85.    DDRA    = 0x3B;   // Puerto A salidas (excepto el pin PTA2).
86.    DDRB    = 0x00;   // Puerto B entradas
87. }
88.  
89. /* Retardo de n ciclos de reloj.
90.  */
91. void delay ( unsigned int ciclos ){
92.    int cuenta;
93.    for ( cuenta = 0; cuenta < ciclos; cuenta++ );
94. }

Decodificador

Código: C

1. /********************************************************************
2.  * Decodificador a tres displays de de 7 segmentos para el multiplicador
3.  * serie.
4.  * Recibe 8 bits de forma serie y lo muestra en tres displays.
5.  ********************************************************************/
6.  
7. #include <MC68HC908QY4.h>   // Se definen los registros de I/O y sus direcciones.
8. #include <hidef.h>         // Contiene instrucciones en ensamblador.
9. #include <startup.h>
10.  
11. // Patrones numéricos a mandar al display de 7 segmentos,
12. // dígitos del 0 al 9.
13. const unsigned char numeros[ 10 ]={ 0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F };
14.  
15. void inicializacion( void );
16. void delay( int );
17.  
18. // Dato binario a mostrar.
19. int dato = 0;
20. int dato_completo = 0;
21. int bits = 0;
22.  
23. void main( void ) {
24.    int unidades, decenas, centenas, aux;
25.    
26.    inicializacion();
27.    
28.    EnableInterrupts;
29.    
30.    while( 1 ) {
31.       centenas = dato_completo / 100;
32.       aux = dato_completo % 100;
33.       decenas = aux / 10;
34.       unidades = aux % 10;
35.      
36.       if ( PTA_PTA1 == 1 ) {
37.          dato = 0;
38.          bits = 0;
39.       }
40.      
41.       // Habilita el primer display
42.       PTA_PTA5 = 0;
43.       PTA_PTA4 = 1;
44.       PTA_PTA3 = 1;
45.       PTB = numeros[ unidades ];
46.       delay( 1000 );
47.      
48.       // Habilita el segundo display y envía
49.       // el número correspondiente a las decenas.
50.       PTA_PTA5 = 1;
51.       PTA_PTA4 = 0;
52.       PTA_PTA3 = 1;
53.       PTB = numeros[ decenas ];
54.       delay( 1000 );
55.      
56.       // Habilita el tercer display y envía
57.       // el número correspondiente a las centenas.
58.       PTA_PTA5 = 1;
59.       PTA_PTA4 = 1;
60.       PTA_PTA3 = 0;
61.       PTB = numeros[ centenas ];
62.       delay( 1000 );
63.      
64.    }
65. }
66.  
67. /* Configura el microcontrolador, puertos de entrada y salida.
68.  */
69. void inicializacion() {
70.    CONFIG1 = 0x09;   // Deshabilita el perro guardián
71.    OSCTRIM = 0x80;   // Registro de ajuste de oscilador interno
72.    DDRA    = 0x38;   // Pines 5,4 y 3 salidas, 0 y 2 entradas.
73.    DDRB    = 0xff;   // Puerto B salidas
74.  
75.    CONFIG2 = 0xc0;   // Resistencia de pull-up habilitada para el pin A2 que
76.                // funciona como IRQ.
77.    INTSCR = 0x00;   // Habilita interrupción por IRQ.
78. }
79.  
80. interrupt 2 void cargar_dato_serie( void ) {
81.    if ( bits < 8 ) {
82.       bits++;
83.       dato = dato | ( PTA_PTA0 << ( 8 - bits ) );
84.    }
85.    else {
86.       dato_completo = dato;
87.       bits = 0;
88.       dato = 0;
89.    }
90.    
91. //   delay( 2000 );
92.    
93.    // Borra la bandera del IRQF1
94.    INTSCR_ACK1 = 1;
95. }
96.  
97. /* Retardo de n ciclos de reloj.
98.  */
99. void delay (int ciclos){
100.    int cuenta;
101.    for (cuenta=0; cuenta < ciclos; cuenta++);
102. }

[Geo]

Multiplicador 4 bits (3)

Multiplicación con un solo microcontrolador, los dos números a multiplicar se introducen alternadamente.

Circuito:
[img=http://img137.imageshack.us/img137/525/06multiplicadorentradaaou0.th.png]

Multiplicador:

Código: C

1. #include <MC68HC908QY4.h>   // Incluye declaraciones de periféricos.
2. #include <startup.h>   // Inicializa pila, variables, etc.
3. #include <hidef.h>      // Contiene instrucciones en ensamblador.
4.  
5. const unsigned char numeros[ 10 ]={ 0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F };
6.  
7. void inicializacion( void );
8. void delay( unsigned int );
9.  
10. int resultado;
11. int numeroA, numeroB;
12. int unidades, decenas, centenas;
13. int aux;
14. int ciclosDibujo;
15.  
16. void main( void ) {
17.    inicializacion();
18.    numeroA = numeroB = 0;
19.    
20.    while( 1 ) {
21.       // Si PTB7 = 0, lee el número A.
22.       if ( PTB_PTB7 == 0 ) {
23.          numeroA = PTA & 0x0F;
24.       }
25.       // Si es 1, lee el número B.
26.       else {
27.          numeroB = PTA & 0x0F;
28.       }
29.      
30.       resultado = numeroA * numeroB;
31.  
32.       centenas = resultado / 100;
33.       aux = resultado % 100;
34.       decenas = aux / 10;
35.       unidades = aux % 10;
36.      
37.       ciclosDibujo = 0;
38.       while ( ciclosDibujo < 20 ) {
39.  
40.          // Habilita primer display
41.          PTA_PTA4 = 0;
42.          PTA_PTA5 = 1;
43.          PTB = numeros[ centenas ];
44.          delay( 1000 );
45.          
46.          // Segundo display
47.          PTA_PTA4 = 1;
48.          PTA_PTA5 = 0;
49.          PTB = numeros[ decenas ];
50.          delay( 1000 );
51.          
52.          // Tercer display
53.          PTA_PTA4 = 1;
54.          PTA_PTA5 = 1;
55.          PTB = numeros[ unidades ];
56.          delay( 1000 );
57.          
58.          ciclosDibujo++;
59.       }
60.    }
61. }
62.  
63. void inicializacion( void ) {
64.    CONFIG1 = 0x09;      // Deshabilita el perro guardián.
65.    OSCTRIM = 0x80;      // Oscilador interno.
66.    DDRA = 0x30;      // Pines 4 y 5 salidas, el resto entradas.
67.    PTAPUE = 0x0F;      // Resistencias de pull-up pines 0,1,2 y 3.
68.    DDRB = 0x7F;      // Pin 7 entrada, el resto salidas.
69.    PTBPUE = 0x80;      // Resistencia de pull-up del puerto B.
70. }
71.  
72. void delay( unsigned int n ) {
73.    unsigned int i;
74.    for ( i = 0; i < n; i++ );
75. }

[Geo]

Voltímetro

Código: C

1. #include <MC68HC908QY4.h>   // Definición registros entrada/salida.
2. #include <hidef.h>         // Instrucciones en ensamblador.
3. #include <startup.h>      // Inicializa pila, variables, etc.
4.  
5. // Patrones numéricos a mandar al display de 7 segmentos,
6. // dígitos del 0 al 9.
7. const unsigned char digitos[ 10 ]={ 0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F };
8.  
9. void inicializacion( void );
10. void delay( unsigned int );
11.  
12. unsigned char voltaje;
13. unsigned char unidades, decimas;
14. int aux;
15.  
16. #define TOTAL_CICLOS 20
17. unsigned int ciclos;
18.  
19.  
20. void main( void ) {
21.    inicializacion();
22.    
23.    while ( 1 ) {
24.  
25.       // Obtiene volts
26.       // 1 V = 51
27.       unidades = ADR / 51;
28.  
29.       // el resto se usa para calcular las décimas
30.       aux = ADR % 51;
31.       decimas = ( aux * 10 ) / 51;
32.      
33.       ciclos = 0;
34.       while ( ciclos < TOTAL_CICLOS ) {
35.  
36.          // activa display de volts
37.          PTA_PTA0 = 0;
38.          PTA_PTA1 = 1;
39.          PTB = digitos[ unidades ];
40.          delay( 1000 );
41.  
42.          // activa display de décimas de volts
43.          PTA_PTA0 = 1;
44.          PTA_PTA1 = 0;
45.          PTB = digitos[ decimas ];
46.          delay( 1000 );
47.          
48.          ciclos++;
49.       }
50.  
51.    }
52. }
53.  
54. void inicializacion( void ) {
55.    CONFIG1 = 0x09;      // Deshabilita el perro guardián.
56.    OSCTRIM = 0x80;      // Ajusta oscilador interno.
57.    DDRA = 0x1B;      // Pines A5 (AD3) y AD2 entradas, pines A0, A1, A3 y A4 salidas
58.                   // (para controlar displays).
59.    DDRB = 0xFF;      // Puerto B salidas.
60.    
61.    ADICLK = 0x40;      // Divisor de velocidad del bus entre 4 para
62.                   // que el ADC trabaje a 3.2 MHz / 4 < 1 MHz.
63.    ADSCR = 0x23;      // Conversiones continuas, interrupciones
64.                   // deshabilitadas. Canal 3 (pin A5).
65. }
66.  
67. void delay( unsigned int n ) {
68.    unsigned int i;
69.    for ( i = 0; i < n; i++ );
70. }

[scientist]

gracias geo, me has hecho un grandisimo favor, he estado dos dias dandole al adc sin poder hacer chambear, al fin, y es que cuando me queda una espinita, no puedo dejar de pensar en otra cosa que eso, 

[wizz]

excelentes ejemplos Geo!

ya logre aplicar el ejemplo de la secuencia de leds  !

no se si ya sea mucho pedir, pero me gustaria pedirte que pusieras algun ejemplo donde se manejen las interrupciones. lo que estoy tratando de hacer es contar los pulsos de un encoder de cuadratura y de lo que he leido una de las formas mas sencillas de hacer esto es conectar un canal del encoder, vamos a decir que el canal A, al puerto IRQ para las interrupciones externas, y el canal B a cualquier puerto de entrada. entonces cuando se habilita la interrupcion verifico el estado del canal B en el puerto y si es 1 entonces incremento la cuenta, si es 0 decremento.

esto en teoria suena muy sencillo, pero no he podido lograrlo.... lo que estoy intentando es conectar el canal B al PTA 0, pero creo que eso me esta ocasionando un corto o algo asi, ya intente con la resistencia de pull up activada y desactivada y con ninguna de los dos funciona, ¿ocupo conectarle algo mas? o ¿es correcto conectar directo el canal del encoder al micro? ¿hay algo que tenga que cambiar en los CONFIG 1 o 2?
ahorita mi inicializacion es:

Código: [Seleccionar]

CONFIG1 = 0x09;   // Deshabilita el perro guardián   
OSCTRIM = 0x80;   // Registro de ajuste de oscilador interno
PTAPUE  = 0x3f;   // Resistencias de pull-up   
DDRA    = 0x38;   // Pines 5,4 y 3 salidas, 0, 1 y 2 entradas.   
DDRB    = 0xff;   // Puerto B salidas   
CONFIG2 = 0x40;   // Resistencia de pull-up habilitada para el pin A2 que             
                  // funciona como IRQ.   <-- ultimo cambio, original 0xc0
INTSCR = 0x00;    // Habilita interrupción por IRQ.
¿esta bien eso?

cualquier ayuda la agradeceria mucho...

saludos

[Geo]

No estoy al día en esto pues los ejercicios los hice algún tiempo, pero aquí vamos .

En el segundo ejemplo de multiplicador, el decodificador utiliza la interrupción externa para recibir ocho bits uno a uno del primer microcontrolador que realiza la multiplicación, ese ejemplo te puede servir.
Por lo que mencionas, me parece que el problema podría ser el voltaje que recibes del encoder, confirma los niveles y las señales que recibes por ese lado. Lo que te recomiendo es que primero hagas un programa para probar el uso de la interrupción externa con un pulsador, con eso estarás seguro de que manejas bien esta parte para luego proceder con la otra.

En cuanto al programa, quizá esto te pueda servir:
http://ar.geocities.com/valdezda/microcontroladores/encoderrot.htm
http://www.micropic.es/index.php?option=com_content&task=view&id=18&Itemid=44

Suerte .

[tatocasta]

Cordial Saludo a Todos....

Me gustaria saber si alguien tiene un ejemplo del uso del Modulo KBI y el manejo de sus interrupciones, pues estoy tratando de configurarlo y por mas que intento pareciera que el programa ni siquiera llega a la interrupcion...

Cualquier ayuda y ejemplo al respecto se agradece...

[scientist]

checate este link, a lo mejor te pueda servir, saludos

tutorial QY4