Practicas con MC68HC908QY4

Practica #1

Lectura de puerto A (interruptores) escritura en puerto B

Código del programa y esquemático

D?

LED0
D?

LED0
D?

LED0
D?

U1 VCC
1 LED0
VDD D?
S? 4 2
PTA5/OSC1/AD3/KBI5 PTB7
5 3
PTA4/OSC2/AD2/KBI4 PTB6
SW-PB 8 6
PTA3/RST/KBI3 PTB5
9 7 LED0
PTA2/IRQ/KBI2 PTB4
GND 12 10
S? PTA1/AD1/TCH1/KBI1 PTB3 D?
13 11
PTA0/AD0/TCH0/KBI0 PTB2 GND
14
PTB1
SW-PB 16 15
VSS PTB0
GND MC68HC908QY4CP LED0
GND D?

LED0
D?

LED0
#include <hidef.h> /* for EnableInterrupts macro */

#include <MC68HC908QY4.h> /* include peripheral declarations */

#include <startup.h>

void inicializacion( void );

void main(void) {

inicializacion();

for(;;){ //ciclo infinito

if ( PTA_PTA0 == 0 ) { //DECLARAMOS CONDICION PARA EL PUERTO A

PTB= 0xFF;

}else{

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.

/* please make sure that you never leave this function */

Practica 2

Contador de pulsos y salida en binario

El mismo esquematico

Programa

#include <hidef.h> /* for EnableInterrupts macro */

#include "derivative.h" /* include peripheral declarations */

#include <startup.h>

unsigned char val=0;

void inicializacion( void );

void retardo( unsigned int );

void main(void) {

inicializacion();

for(;;){

if (PTA_PTA0 == 0){

retardo(20000);

val=val+1;

PTB=val;

/* loop forever */

/* please make sure that you never leave this function */

}
void inicializacion() {

CONFIG1 = 0x09; // Deshabilita el perro guardián

CONFIG2 = 0x00; //Configuramos no reset y cristal interno

OSCTRIM = 0x80; // Registro de ajuste de oscilador interno

PTAPUE = 0x3F; // Resistencias de pull-up

DDRA = 0x10; // Puerto A, entradas.

DDRB = 0xFF; // Puerto B, salidas.

void retardo( unsigned int ciclos ) {

unsigned int cuenta;

for ( cuenta = 0; cuenta < ciclos; cuenta++ );

}
Practica 3

Desplazamiento de leds a la izquierda y a la derecha

Mismo esquematico

Programa

#include <hidef.h> /* for EnableInterrupts macro */

#include "derivative.h" /* include peripheral declarations */

#include <startup.h>

/////variables////////

const unsigned char leds[] = {

0x00, 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01

};

///////funciones//////

void inicializacion(void);

void retardo( unsigned int );

void secIzquierda( void );

void secDerecha( void );

////////programa principal////////////

void main(void) {

inicializacion();

for(;;){

if ( PTA_PTA0 == 0 )

secDerecha();

else if ( PTA_PTA1 == 0 )

secIzquierda();
 else

PTB = leds[ 0 ]; // PTB = 0x00;

/* please make sure that you never leave this function */

void inicializacion() {

CONFIG1 = 0x09; // Deshabilita el perro guardián

CONFIG2 = 0x00;

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 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 );

}
Practica 4

Tarjeta de visualizador de display 7 segmentos

D?

LED0
D?

LED0
D?

LED0
D? DS?
10 1
a K GND
9 6
b K
U1 VCC 8
c
1 LED0 5
VDD D? d
4
S? e
4 2 2
PTA5/OSC1/AD3/KBI5 PTB7 f
5 3 3
PTA4/OSC2/AD2/KBI4 PTB6 g
SW-PB 8 6 7
PTA3/RST/KBI3 PTB5 DP
9 7 LED0
PTA2/IRQ/KBI2 PTB4
GND 12 10 Dpy Amber-CC
S? PTA1/AD1/TCH1/KBI1 PTB3 D?
13 11
PTA0/AD0/TCH0/KBI0 PTB2 GND
14
PTB1
SW-PB 16 15
VSS PTB0
GND MC68HC908QY4CP LED0
GND D?

LED0
D?

LED0
Programa

#include <hidef.h> /* for EnableInterrupts macro */

#include "derivative.h" /* include peripheral declarations */

#include <startup.h>

unsigned char val=0;

void inicializacion(void);

void retardo( unsigned int );

char segmentos( unsigned char );

void main(void) {

inicializacion();

/* include your code here */

for(;;){

if(PTA_PTA0 == 0){

retardo(24000);

val=val+1;

if ( PTA_PTA1 == 0 ){

retardo(24000);

val=val-1;

PTB=segmentos(val);

/* loop forever */

/* please make sure that you never leave this function */

}

void inicializacion(){

CONFIG1=0x09;

CONFIG2=0x00;

OSCTRIM=0x80;

PTAPUE=0x3F;

DDRA = 0x00; // Puerto A ENTRADAS

DDRB = 0xFF; // Puerto B salidas

void retardo( unsigned int ciclos ) {

unsigned int cuenta;

for ( cuenta = 0; cuenta < ciclos; cuenta++ );

char segmentos(unsigned char val){

unsigned char valseg;

switch (val){

case 0:

valseg=0x3F;

break;

case 1:

valseg=0x06;

break;

case 2:
 valseg=0x5B;

break;

case 3:

valseg=0x4F;

break;

case 4:

valseg=0x66;

break;

case 5:

valseg=0x6D;

break;

case 6:

valseg=0x7D;

break;

case 7:

valseg=0x07;

break;

case 8:

valseg=0x7F;

break;
case 9:

valseg=0x6F;

break;

return valseg;

}
Practica 5 y 6

Control de relevador de CA para energizar bomba y para control de triac

Esquemático para triac

R? U? R? CA
Res2 Res2
1K 1K
Q?
Opto TRIAC Triac
GND
DS?

Lamp

K?

U2
18 1
OUT1 IN1
17 2
OUT2 IN2
16 3 VCC
OUT3 IN3
15 4
OUT4 IN4
14 5
OUT5 IN5
13 6
OUT6 IN6
12 7 Relay-DPST
OUT7 IN7
11 8
OUT8 IN8
10 9
VCC K GND
ULN2803A
D?
GND
D Zener

GND
Esquema para relevador

ULN2803A
D?
D Zener
VCC

R?
GND RPot
1K U1 VCC
1
VDD
S? GND4 2
PTA5/OSC1/AD3/KBI5 PTB7
5 3
PTA4/OSC2/AD2/KBI4 PTB6
SW-PB 8 6
PTA3/RST/KBI3 PTB5
9 7
PTA2/IRQ/KBI2 PTB4
12 10
S? PTA1/AD1/TCH1/KBI1 PTB3
13 11
PTA0/AD0/TCH0/KBI0 PTB2
14
PTB1
SW-PB 16 15
VSS PTB0
MC68HC908QY4CP
GND

Programa, aquí se utilizo el ADC del micro para activar una salida a partir de que rebasa los 2.5
volts en el AN3, pin 4

#include <hidef.h> /* for EnableInterrupts macro */

#include "derivative.h" /* include peripheral declarations */

#include <startup.h>

byte result;
void inicializacion(void);

void main(void) {

inicializacion();

for(;;){

ADSCR = 0x23;

result = ADR;

PTB=result;

if(result>0x7F){

PTA_PTA0=1;

}else{

PTA_PTA0=0;

/* loop forever */

/* please make sure that you never leave this function */

}
void inicializacion(){

CONFIG1=0x09;

OSCTRIM=0x80;

DDRA = 0x1B;

DDRB = 0xFF;

ADICLK = 0x40;

ADSCR = 0x23;

}
Practica 7

Manejo de un teclado numérico y mostrar la tecla en un display 7 segmentos

Esquematico

U?
1 S? S? S?
VDD
DS?
5 2 4 SW-PB SW-PB SW-PB
DP PTB7 PTA5/OSC1/AD3/KBI5
10 3 5
g PTB6 PTA4/OSC2/AD2/KBI4
9 6 8
f PTB5 PTA3/RST/KBI3
1 7 9
e PTB4 PTA2/IRQ/KBI2
2 10 12
d PTB3 PTA1/AD1/TCH1/KBI1 S? S? S?
4 11 13
c PTB2 PTA0/AD0/TCH0/KBI0
8 6 14
K b PTB1
3 7 15 16 SW-PB SW-PB SW-PB
K a PTB0 VSS
Dpy Blue-CC MC68HC908QY4CP

S? S? S?

SW-PB SW-PB SW-PB

Código de programa

#include <hidef.h> /* for EnableInterrupts macro */

#include "derivative.h" /* include peripheral declarations */

#include <startup.h>

void inicializacion(void);

void retardo( unsigned int );

void main(void) {

inicializacion();

EnableInterrupts; /* enable interrupts */

/* include your code here */

PTB=0x00;

for(;;) {

PTA_PTA0=1;

if((PTA_PTA3==1)&&(PTA_PTA0==1)){
PTB=0x06;

retardo(24000);

if((PTA_PTA4==1)&&(PTA_PTA0==1)){

PTB=0x5B;

retardo(24000);

if((PTA_PTA5==1)&&(PTA_PTA0==1)){

PTB=0x4F;

retardo(24000);

PTA_PTA0=0;

PTA_PTA1=1;

if((PTA_PTA3==1)&&(PTA_PTA1==1)){

PTB=0x66;

retardo(24000);

if((PTA_PTA4==1)&&(PTA_PTA1==1)){

PTB=0x6D;

retardo(24000);

if((PTA_PTA5==1)&&(PTA_PTA1==1)){

PTB=0x7D;

retardo(24000);
}

PTA_PTA1=0;

PTA_PTA2=1;

if((PTA_PTA3==1)&&(PTA_PTA2==1)){

PTB=0x07;

retardo(24000);

if((PTA_PTA4==1)&&(PTA_PTA2==1)){

PTB=0x7F;

retardo(24000);

if((PTA_PTA5==1)&&(PTA_PTA2==1)){

PTB=0x67;

retardo(24000);

PTA_PTA2=0;

__RESET_WATCHDOG(); /* feeds the dog */

 } /* loop forever */

/* please make sure that you never leave main */

void inicializacion(){

CONFIG1=0x09;

OSCTRIM=0x80;

DDRA = 0x07;

DDRB = 0xFF;

void retardo( unsigned int ciclos ) {

unsigned int cuenta;

for ( cuenta = 0; cuenta < ciclos; cuenta++ );

}
Practica 8

Control de Motor PP velocidad y direccion

Esquematico, el que vemos anteriormente, con el uln2803 y las salidas al motor PP , la dirección la
controlas por los dipswitch de a0 y a1, y la velocidad mediante el potenciómetro, dependiendo del
valor analógico mayor es la velocidad

S?

GND SW-PB
S?

SW-PB
VCC

R? U? VCC VCC P?
RPot 1 U?
1K VDD 1
1 18
IN1 OUT1 2
4 2 2 17
PTA5/OSC1/AD3/KBI5 PTB7 IN2 OUT2 3
5 3 3 16
PTA4/OSC2/AD2/KBI4 PTB6 IN3 OUT3 4
8 6 4 15
PTA3/RST/KBI3 PTB5 IN4 OUT4 5
GND 9 7 5 14
PTA2/IRQ/KBI2 PTB4 IN5 OUT5
12 10 6 13 Header 5
PTA1/AD1/TCH1/KBI1 PTB3 IN6 OUT6
13 11 7 12
PTA0/AD0/TCH0/KBI0 PTB2 IN7 OUT7
14 8 11
PTB1 IN8 OUT8
16 15
VSS PTB0
9 10
GND COM D
MC68HC908QY4CP
GND ULN2803A
D?
GND
D Zener

VCC

Programa

#include <hidef.h> /* for EnableInterrupts macro */

#include "derivative.h" /* include peripheral declarations */

#include <startup.h>
const unsigned char leds[] = {

0x01, 0x02, 0x04, 0x08

};

unsigned int valor;

void inicializacion(void);

void retardo (unsigned int);

void secIzquierda( void );

void secDerecha( void );

void main(void) {

inicializacion();

for(;;) {
 ADSCR = 0x23;

valor = ADR;

valor = valor*200;

if(PTA_PTA0 == 0)

secDerecha();

else if (PTA_PTA1 == 0)

secIzquierda();

else

PTB = 0x00; // PTB = 0x00;

__RESET_WATCHDOG(); /* feeds the dog */

} /* loop forever */

/* please make sure that you never leave main */

}
void inicializacion(){

CONFIG1= 0x09;

OSCTRIM = 0x80;

PTAPUE = 0x1F; // Resistencias de pull-up

DDRA = 0x00; // Puerto A, entradas.

DDRB = 0xFF; // Puerto B, salidas.

ADICLK = 0x40; // Divisor de velocidad del bus entre 4 para

// que el ADC trabaje a 3.2 MHz / 4 < 1 MHz.

// Conversiones continuas, interrupciones

void retardo( unsigned int ciclos ) {

unsigned int cuenta;

for ( cuenta = 0; cuenta < ciclos; cuenta++ );

void secDerecha() {
 int cuenta;

for ( cuenta = 0; cuenta < 4; cuenta++ ) {

PTB = leds[ cuenta ];

retardo( valor );

void secIzquierda() {

int cuenta;

for ( cuenta = 3; cuenta >= 0; cuenta-- ) {

PTB = leds[ cuenta ];

retardo( valor );

}
Practica 9

Medición de velocidad de un motor de CD para formar grafica

J?
U? VCC U? C? VCC 1
1 1 2 6
2

Y? VDD C1+ VDD

3 16 2 11
XTAL 4 C1- VCC Cap Pol1
1M 2 4 7
PTA5/OSC1/AD3/KBI5 PTB7 C2+
5 3 5 VCC10uF 3 10
1

S? PTA4/OSC2/AD2/KBI4 PTB6 C2-

8 6 8
PTA3/RST/KBI3 PTB5
9 7 11 14 4
PTA2/IRQ/KBI2 PTB4 T1IN T1OUT
SW-PB 12 10 10 7 9
PTA1/AD1/TCH1/KBI1 PTB3 T2IN T2OUT
13 11 5
PTA0/AD0/TCH0/KBI0 PTB2
GND 14 12 13
PTB1 R1OUT R1IN
16 15 9 8 D Connector 9
VSS PTB0 R2OUT R2IN
C? GND
MC68HC908QY4CP 15 6
GND VEE GND
GND
MAX232ACPE Cap Pol1
GND 10uF

Programa, lo que va a hacer, es mediante la interrupción externa, nosotros vamos a poder contar
los pulsos que nos va a indicar un optointerruptor, y cada segundo, se va a desplegar la velocidad
en la computadora mediante la hyperterminal

Código

#include <hidef.h> /* for EnableInterrupts macro */

#include "derivative.h" /* include peripheral declarations */

#include <startup.h>
unsigned char flag=0;

interrupt 2 void cargar_dato_serie(void);

interrupt 6 void TIMER();

void delay_baudio(void);

unsigned char tiempo_bit;

void inicializacion(void);

void Configurar_Timer(void);

void Transmitir_Caracter(void);

unsigned char Caracter =0;

unsigned char bit;

void main(void) {

inicializacion();

Configurar_Timer();

EnableInterrupts;
PTB=0x00;

for(;;) {

__RESET_WATCHDOG(); /* feeds the dog */

} /* loop forever */

/* please make sure that you never leave main */

void inicializacion() {

CONFIG1 = 0x09; // Deshabilita el perro guardián

// Registro de ajuste de oscilador interno

DDRA = 0x38; // Pines 5,4 y 3 salidas, 0 y 2 entradas.

DDRB = 0xff; // Puerto B salidas

 CONFIG2 = 0x58; // Resistencia de pull-up habilitada para el pin A2 que

// funciona como IRQ.

INTSCR = 0x00; // Habilita interrupción por IRQ.

//////////CONFIGURACION TIMER REGISTROS////////////

void Configurar_Timer(void){

TSC = 0X70; /*Stop & reset,interrupcion activa, prescaler= 0*/

TSC0 = 0; /*Resto de funciones desactivadas*/

TSC1 = 0;

TMODH = 0xFF; /* Se carga el módulo con 04E4 (1252 decimal)*/

TMODL = 0xFF;

TSC ^= 0x10; /*Un-reset TIMer*/

///////////interrupcion externa////////////////
interrupt 2 void cargar_dato_serie( void ) {

flag++;

// Borra la bandera del IRQF1

INTSCR_ACK = 1;

////////////INTERRUPCION TIMER///////////////

interrupt 6 void TIMER(){

Caracter=flag;

Transmitir_Caracter();

flag=0;

TSC ^= 0x80; /* Se borra la bandera de la interrupción */

/*******************************************************/
/* Subrutina que maneja el Tranmisor */

/*******************************************************/

void Transmitir_Caracter(void){

//DisableInterrupts; /*Interrupciones Desactivadas*/

__RESET_WATCHDOG();

bit =0;

PTB_PTB0 = 0; //Pongo el bit de inicio

delay_baudio();

do{

if(Caracter & 0x01 == 0x01){

PTB_PTB0 = 1; //Pongo TX en 1

delay_baudio();

else

PTB_PTB0 = 0; //Pongo TX en 0

delay_baudio();

Caracter = Caracter >>1; //Roto para pasar los 8 bits

bit++;

}while(bit <=7);

PTB_PTB0 = 1; //Pongo el bit de Stop

delay_baudio();

__RESET_WATCHDOG();

}
void delay_baudio(void){

for(tiempo_bit=0;tiempo_bit <=10;tiempo_bit++){