#include <hidef.h> //Contiene instrucciones en ensamblador.
#include <MC68HC908QY4.h> //Se definen los registros de I/O y sus direcciones.
#include <startup.h>
const unsigned char leds[] = {
0x00, 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01
};
void inicializacion( void );
void retardo( unsigned int );
void secParpadeo( void );
void secIzquierda( void );
void secDerecha( void );
void secEncuentro( void );
void secTrenecito( void );
void main( void ) {
inicializacion();
while( 1 ) {
if ( PTA_PTA0 == 0 )
secParpadeo();
else if ( PTA_PTA1 == 0 )
secDerecha();
else if ( PTA_PTA2 == 0 )
secIzquierda();
else if ( PTA_PTA3 == 0 )
secEncuentro();
else if ( PTA_PTA4 == 0 )
secTrenecito();
else
PTB = leds[ 0 ]; // PTB = 0x00;
}
}
void inicializacion() {
CONFIG1 = 0x09; // Deshabilita el perro guardián
OSCTRIM = 0x80; // Registro de ajuste de oscilador interno
PTAPUE = 0x3F; // Resistencias de pull-up
DDRA = 0x00; // Puerto A, entradas.
DDRB = 0xFF; // Puerto B, salidas.
}
void retardo( unsigned int ciclos ) {
unsigned int cuenta;
for ( cuenta = 0; cuenta < ciclos; cuenta++ );
}
void secParpadeo() {
PTB = ~PTB;
retardo( 20000 );
}
void secDerecha() {
int cuenta;
for ( cuenta = 0; cuenta < 9; cuenta++ ) {
PTB = leds[ cuenta ];
retardo( 20000 );
}
}
void secIzquierda() {
int cuenta;
for ( cuenta = 8; cuenta >= 0; cuenta-- ) {
PTB = leds[ cuenta ];
retardo( 20000 );
}
}
void secEncuentro() {
int cuentaA, cuentaB;
// Leds apagados.
PTB = leds[ 0 ];
retardo( 30000 );
for ( cuentaA = 1, cuentaB = 8; cuentaA < 9, cuentaB > 0; cuentaA++, cuentaB-- ) {
PTB = leds[ cuentaA ] | leds[ cuentaB ];
retardo( 30000 );
}
}
void secTrenecito() {
int cuenta;
for ( cuenta = 0; cuenta < 9; cuenta++ ) {
PTB = PTB | leds[ cuenta ];
retardo( 30000 );
}
for ( cuenta = 0; cuenta < 9; cuenta++ ) {
PTB = PTB & ( ~leds[ cuenta ] );
retardo( 30000 );
}
}
const unsigned char secuencia[] = { 0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff, 0xfe, 0xfc, 0xf8, 0xe0, 0xc0, 0x80 };
void trenecito( void ) {
int cuenta;
for ( cuenta = 0; cuenta < 16; cuenta++ ) {
PTB = secuencia[ cuenta ];
retardo( 20000 );
}
}
En este caso, esta segunda forma de realizar la secuencia permite hacer más pequeño el código resultante, lo que podría ser importante en caso de que necesitáramos optimizar espacio en el microcontrolador.#include <hidef.h> //Contiene instrucciones en ensamblador.
#include <MC68HC908QY4.h> //Se definen los registros de I/O y sus direcciones.
#include <startup.h>
int unidades, decenas, centenas;
int cuenta, aux;
const unsigned char numeros[ 10 ]=
{
0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F
};
//const unsigned char numeros[ 10 ] = { 0x7e, 0x30, 0x6d, 0x79, 0x33, 0x5b, 0x5f, 0x70, 0x7f, 0x7b };
void inicializacion( void );
void delay( int );
void main(void) {
int retardo_displays;
inicializacion();
while( 1 ) {
cuenta++;
if ( cuenta > 999 ) {
unidades = decenas = centenas = 0;
cuenta = 0;
}
centenas = cuenta / 100;
aux = cuenta % 100;
decenas = aux / 10;
aux = aux % 10;
unidades = aux;
retardo_displays = 0;
while( retardo_displays < 10 ) {
// Activa display de unidades
delay( 1000 );
PTA = ~0x01;
PTB = numeros[ unidades ];
// Decenas
delay( 1000 );
PTA = ~0x02;
PTB = numeros[ decenas ];
// Centenas
delay( 1000 );
PTA = ~0x08;
PTB = numeros[ centenas ];
retardo_displays++;
}
}
}
void inicializacion() {
CONFIG1=0x09; //Deshabilita el perro guardián
OSCTRIM = 0x80; //Registro de ajuste de oscilador interno
DDRA = 0xFF; // Puerto A salidas
DDRB = 0xFF; // Puerto B salidas
unidades = decenas = centenas = 0;
}
void delay( int ciclos ) {
int i;
for ( i = 0; i < ciclos; i++ );
}
/**************************************************
* José Jorge Enríquez Rodríguez
**************************************************
* Sumador / restador.
* Suma o resta un par de datos de 4 bits.
* El resultado de la operación es de 5 bits.
**************************************************
* Entradas
* --------
* PTB7 a PTB4 - Dato A, MSB a LSB.
* PTB3 a PTB0 - Dato B, MSB a LSB.
* PTA2 - Cin, selector suma/resta.
*
* Salidas
* -------
* PTA5, PTA4, PTA3, PTA1, PTA0 - Resultado.
**************************************************
*/
#include <MC68HC908QY4.h> // Se definen los registros de I/O y sus direcciones.
#include <hidef.h> // Contiene instrucciones en ensamblador.
#include <startup.h>
/***************************
* Declaración de funciones
***************************/
void inicializacion( void );
void delay( int );
/* cin : Selector 0 - suma, 1 - resta.
* dato_a, dato_b: números de 4 bits a sumar/restar
* resultado: resultado de la operación.
*/
int cin, dato_a, dato_b, resultado;
/**********************
* Programa principal
**********************/
void main ( void ){
inicializacion();
while (1){
// El dato A es la parte alta (4 bits) del puerto B.
dato_a = ( PTB >> 4 );
// El dato B es la parte baja (4 bits) del puerto B.
dato_b = ( PTB & 0x0F );
// Selector suma/resta.
cin = PTA_PTA2;
// Si el selector es 0, suma; si no, resta.
if ( cin == 0 )
resultado = dato_a + dato_b;
else
resultado = dato_a - dato_b;
// Si el resultado es negativo, lo complementa a 2
// (Esto da un resultado correcto, aunque el signo no se indica
// y debe tomarse en cuenta al realizar la operación).
if ( resultado < 0 ) {
resultado = ( ~resultado ) + 1;
}
// El resultado (5 bits), se muestra en los pines
// 5, 4, 3, 1 y 0 del puerto A.
PTA_PTA5 = ( resultado & 0x10 ) >> 4;
PTA_PTA4 = ( resultado & 0x08 ) >> 3;
PTA_PTA3 = ( resultado & 0x04 ) >> 2;
PTA_PTA1 = ( resultado & 0x02 ) >> 1;
PTA_PTA0 = ( resultado & 0x01 );
delay( 10000 );
}
}
/* Configura el microcontrolador, puertos de entrada y salida.
*/
void inicializacion() {
CONFIG1 = 0x09; // Deshabilita el perro guardián
OSCTRIM = 0x80; // Registro de ajuste de oscilador interno
PTBPUE = 0xFF; // Resistencias de pull-up para el puerto B (todos los pines).
PTAPUE = 0x04; // Resistencia de pull-up para el puerto A (solamente el pin PTA2).
DDRA = 0x3B; // Puerto A salidas (excepto el pin PTA2).
DDRB = 0x00; // Puerto B entradas
}
/* Retardo de n ciclos de reloj.
*/
void delay (int ciclos){
int cuenta;
for ( cuenta = 0; cuenta < ciclos; cuenta++ );
}/**************************************************
* José Jorge Enríquez Rodríguez
**************************************************
* Decodificador 5 bits a dos displays de 7 segmentos.
* Recibe un dato binario de 5 bits y lo muestra en decimal
* en un par de displays de 7 segmentos (se usaron de cátodo común).
**************************************************
* Entradas
* --------
* PTA0 a PTA4 - Dato de 5 bits.
*
* Salidas
* -------
* PTA0 a PTA6 - Segmentos de los displays.
* PTB7 - Cátodo display decenas.
* PTA5 - Cátodo display unidades.
**************************************************
*/
#include <MC68HC908QY4.h> // Se definen los registros de I/O y sus direcciones.
#include <hidef.h> // Contiene instrucciones en ensamblador.
#include <startup.h>
// Patrones numéricos a mandar al display de 7 segmentos,
// dígitos del 0 al 9.
const unsigned char numeros[ 10 ] = {
0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F
};
/****************************
* Declaración de funciones.
****************************/
void inicializacion( void );
void delay( int );
// Dato binario a mostrar.
int dato;
/***********************
* Programa principal.
***********************/
void main( void ) {
// Auxiliares para separar el dato en dos dígitos:
// unidades y decenas.
int unidades, decenas;
inicializacion();
while( 1 ) {
// Leemos el dato en el puerto A (5 bits).
dato = PTA & 0x1f;
// Separa el número en dos dígitos.
decenas = dato / 10;
unidades = dato % 10;
// Habilita el primer display y envía el número
// correspondiente a las unidades.
PTB_PTB7 = 0;
PTA_PTA5 = 1;
PTB = numeros[ unidades ];
delay( 1000 );
// Habilita el segundo display en envía el número
// correspondiente a las decenas.
PTB_PTB7 = 1;
PTA_PTA5 = 0;
// Nota: se emplea una operación | 0x80 ya que el pin 7
// del puerto B también se utiliza para deshabilitar el
// display de unidades, por lo que se debe asegurar que
// esté en 1.
PTB = numeros[ decenas ] | 0x80;
delay( 1000 );
}
}
/* Configura el microcontrolador, puertos de entrada y salida.
*/
void inicializacion() {
CONFIG1 = 0x09; // Deshabilita el perro guardián
OSCTRIM = 0x80; // Registro de ajuste de oscilador interno
DDRA = 0x20; // Pin 5 - salida, Pines 4 a 0 entradas
DDRB = 0xff; // Puerto B salidas
}
/* Retardo de n ciclos de reloj.
*/
void delay (int ciclos){
int cuenta;
for (cuenta=0; cuenta < ciclos; cuenta++);
}la verdad que lo que hace falta es un buen programador y un buen compilador gratuito para qu estos micros despeguen
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 agradecidoAhorita voy a poner unas variaciones del multiplicador de 4 bits, luego pongo un voltímetro, espero que te sirva ese :).
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.pido perdon a todos los que pueda incomodar, soy nuevo en esto de los foros y los microcontroladores freescale. actualemente acabo de adquirrir un programador para micros freescale pero no se como debo configurarlo para poder programar con el. si en algo sirve puedo adjuntar una imagen del programador.
gracias de antemano a todos por su ayuda... :)