Maestro de programación Scl
# include & ltintrins.h & gt//Contiene el archivo de encabezado de la definición de función _nop_()
Número de código de carácter sin signo [10] = { " 0123456789 " } // Definir la matriz de caracteres para mostrar los números.
sbit sclk=p1^0; //bit define la interfaz del chip 1302 y el puerto de salida del reloj está definido en el pin P1.0.
sbit data=p1^1; // El bit define la interfaz del chip 1302 y la salida de datos se define en el pin P1.1.
sbit rst=p1^2; // El bit define la interfaz del chip 1302 y el puerto de reinicio está definido en el pin P1.2.
/****************************************** *************
Función: Retraso de unos microsegundos.
Parámetro de entrada:n
********************************* **** *******************/
void delaynus(carácter sin firmar n)
{
Carácter sin signo I;
for(I = 0;i<n;i++);
}
/******** * ********************************************
Función: Escribe un byte de datos en 1302.
Parámetros de entrada:x
********************************* **** *******************/
void Write1302 (datos de caracteres sin firmar)
{
Carácter sin signo I;
SCLK = 0; //Baja SCLK para prepararse para escribir datos en el flanco ascendente del pulso.
Delenus(2); //Espera un momento y prepara el hardware.
for(I = 0;I<8;I++) //Escribe continuamente datos de 8 bits.
{
datos = fecha y hora. 0x 01; // Obtenga los datos de 0 bits de dat y escríbalos de acuerdo con el bit bajo de 1302.
, alto en la espalda.
Delenus(2); //Espera un momento y prepara el hardware.
SCLK = 1; //Escribe datos en el flanco ascendente
Delenus(2); //Espera un momento y prepara el hardware.
SCLK = 0; // Baja SCLK nuevamente para formar un pulso.
dat & gt& gt=1;// Mueva el bit de datos de dat 1 bit hacia la derecha y prepárese para escribir.
Siguiente bit de datos
}
}
/****************** *****************************************
Función : Según la palabra de comando Escriba un byte de datos en 1302.
Parámetros de entrada: Cmd, almacena la palabra de comando; Dat, almacena los datos a escribir.
********************************************* *** ********/
void WriteSet1302 (carácter sin firmar Cmd, carácter sin firmar dat)
{
RST = 0; / Deshabilitar la transmisión de datos
SCLK = 0; //Asegúrese de que el SCLK con la mayor cantidad de escrituras esté bajo.
RST = 1; //Iniciar transferencia de datos
Delenus(2); //Espera un momento y prepara el hardware.
escribir 1302(Cmd); //Escribir palabra de comando
escribir 1302(dat); //Escribir datos
SCLK = 1; el nivel del reloj está alto.
RST = 0; //Desactivar transmisión de datos
}
/****************** ***********************************
Función: Leer uno de 1302 Bytes de datos.
Parámetros de entrada: x
********************************* **** *******************/
Carácter sin firmar leído 1302 (nulo)
{
Unsigned char i, dat
delenus(2); //Espera un momento y prepara el hardware.
for(I = 0;I<8;I++) //Leer continuamente datos de 8 bits.
{ dat & gt& gt=1;
If(DATA==1) //Si los datos leídos son 1,
dat | / Saque 1 y escriba el bit más alto de dat.
SCLK = 1; //Establece SCLK alto para leer el flanco descendente.
delinus(2); //Espera un momento
SCLK = 0; //Baja SCLK para formar un flanco de pulso descendente.
Delenus(2); //Espera un momento
}
Devuelve dat //Devuelve los datos leídos.
}
/************************************ *******************
Función: Leer un byte de datos de 1302 según la palabra de comando.
Parámetros de entrada: Cmd
********************************* **** *******************/
Conjunto de lectura de caracteres sin firmar 1302 (comando de caracteres sin firmar)
{< / p>
Unsigned char dat
RST = 0; //Despliegue RST
SCLK = 0 //Asegúrese de que el SCLK con la mayor cantidad de escrituras esté bajo.
RST = 1; //Iniciar transmisión de datos
escribir 1302(Cmd); //Escribir palabra de comando
dat = leer 1302(); Leer datos
SCLK = 1; //Coloca el nivel del reloj en un estado conocido.
RST = 0; //Deshabilitar la transmisión de datos
Devolver dat //Devuelve los datos leídos.
}
/************************************ *******************
Función: 1302 se utiliza para la configuración de inicialización.
********************************************* *** ********/
void Init_DS1302 (no válido)
{
Indicador de carácter sin firmar;
flag = readset 1302(0x 81);
if (flag & amp0x 80){//Determina si el chip del reloj está apagado.
WriteSet1302(0x8E, 0x 00); // Según el comando de registro de estado de escritura
palabra, escribe instrucciones desprotegidas
WriteSet1302(0x80, ((55) / 10)<<4|(55%10)));// De acuerdo con la palabra de comando de escritura del segundo registro
, escriba el valor inicial de segundos.
WriteSet1302(0x82, ((59/10)& lt;& lt4|(59%10)));//Según el comando de escritura del subregistro
Escribe el valor inicial del valor minuto.
WriteSet1302(0x84, ((23/10)& lt;& lt4|(23%10)));//Escribe la hora inicial según el comando de registro de hora de escritura
valor.
WriteSet1302(0x86, ((18/10)& lt;& lt4|(18%10)));// Según el comando para escribir el registro
Escribir Valor inicial del día
WriteSet1302(0x88, ((6/10)<<4|(6%10)));//Escribe el registro del mes según la palabra de comando
Escribe el valor inicial del mes.
WriteSet1302(0x8c, ((9/10)& lt;& lt4|(9%10)));// Según el comando de escritura del registro del año
Escribe el comienzo del valor del año.
WriteSet1302(0x90, 0x a5); //Activa la función de carga y selecciona 2K
Modo de carga de resistencia
WriteSet1302(0x8E, 0x 80); // De acuerdo con la declaración escrita
Palabra de comando de registro de estado, escriba la instrucción de protección
}
}
//Si no No quiero inicializar la hora cada vez, es decir, si quieres que el reloj siga funcionando después de un corte de energía, úsalo.
La declaración anterior
/*: esta es una declaración que debe inicializarse cada vez.
/*
WriteSet1302(0x8E, 0x 00); // Según la palabra de comando del registro de estado de escritura
, escribe instrucciones desprotegidas
WriteSet1302(0x80, ((55/10)& lt;& lt4|(55%10)));// Según la segunda palabra de comando de registro de escritura
, escriba el valor inicial de segundos .
WriteSet1302(0x82, ((59/10)& lt;& lt4|(59%10)));//Según el comando de escritura del subregistro
Escribe el valor inicial del valor minuto.
WriteSet1302(0x84, ((23/10)& lt;& lt4|(23%10)));//Escribe la hora inicial según el comando de registro de hora de escritura
valor.
WriteSet1302(0x86, ((18/10)& lt;& lt4|(18%10)));// Según el comando para escribir el registro
Escribir Valor inicial del día
WriteSet1302(0x88, ((6/10)<<4|(6%10)));//Escribe el registro del mes según la palabra de comando
Escribe el valor inicial del mes.
WriteSet1302(0x8c, ((9/10)& lt;& lt4|(9%10)));// Según el comando de escritura del registro del año
Escribe el comienzo del valor del año.
WriteSet1302(0x90, 0x a5); //Activa la función de carga y selecciona 2K
Modo de carga de resistencia
WriteSet1302(0x8E, 0x 80); // De acuerdo con la palabra del comando de registro de estado de escritura
, comando de protección de escritura
*/
/************ ************************************************* ***** **
************
El siguiente es el procedimiento operativo del módulo LCD.
********************************************* *** *******************************
********** **/
sbit rs=p2^0; //Registra el bit de selección, define el bit RS como el pin P2.0.
sbit rw=p2^1; //Lee y escribe el bit de selección y define el bit RW como el pin P2.1.
sbit e=p2^2; //Habilita el bit de señal, define el bit E como pin P2.2.
sbit bf=p0^7; //Bit de indicador de ocupado y define el bit BF como el pin P0.7.
/****************************************** *************
Función: Retraso 1 milisegundo
(3j+2)* I =(3×33+2)×10 = 1010 ( microsegundo), se puede considerar como 1 milisegundo.
********************************************* *** ********/
Retraso no válido 1 milisegundo ()
{
Carácter sin firmar I, j;
para(I = 0;i<10;i++)
para(j = 0;j<33;j++)
;
}
/************************************************ ** *********
Función: Retraso de unos milisegundos.
Parámetros de entrada: n
********************************* **** *******************/
retraso nulo (carácter n sin firmar)
{
carácter sin firmar I;
for(I = 0;i<n;i++)
retraso 1 ms();
}
/************************************************ ******
Función: Determina el estado de ocupado del módulo LCD.
Valor de retorno: resultado. Resultado=1, ocupado Resultado=0, no ocupado
********************************* *** *************************/
bit BusyTest(vacío)
{
resultado del bit;
RS = 0; // Según las regulaciones, cuando RS es de nivel bajo y RW es de nivel alto, se puede leer.
Caso
RW = 1;
e = 1; //E=1 para permitir lectura y escritura.
_ nop _(); //Sin operación
_ nop _();
_ nop _();
_ nop _(); // Ejecutar inactivo durante cuatro ciclos de la máquina para darle tiempo de reacción al hardware.
result = BF //Asignar nivel de indicador de ocupado al resultado
e = 0; //Restaurar E a nivel bajo.
Devolver resultados;
}
/************************ *****************************
Función: escribir instrucciones de configuración de modo o mostrar direcciones en el módulo LCD.
Parámetros de entrada: normativa
******************************** **** *******************/
void WriteInstruction (instrucción de carácter sin firmar)
{
while(busy test()== 1); //Si estás ocupado, espera.
RS = 0; //De acuerdo con las regulaciones, cuando RS y R/W son bajos, se pueden escribir instrucciones
.
RW = 0;
e = 0; //E se establece en bajo (según la Tabla 8-6, al escribir instrucciones, E es
pulso alto,
// Deje que E salte de 0 a 1, así que establezca "0" primero
_ nop _();
_ nop _. (); // Ejecuta la máquina durante dos ciclos para darle tiempo de respuesta al hardware
P0 = Dictado; //Envía datos al puerto P0, es decir, escribe instrucciones o direcciones. >
_ nop _();
_ nop _();
_ nop _();
_ nop _(); /Ejecute cuatro ciclos de máquina inactiva, dando tiempo de reacción al hardware
e = 1; //E está configurado en nivel alto
_ nop.
_ nop _();
_ nop _(); // Ejecutar inactivo durante cuatro ciclos de la máquina para darle tiempo al hardware para reaccionar >e = 0; nivel a nivel bajo, el módulo LCD
comienza a ejecutar el comando
}
/*** *********** **************************************
Función: Especificar la dirección real de visualización de caracteres
Parámetro de entrada: x
****************** **********. **************************/
void WriteAddress(carácter sin firmar x)
{
escribir instrucción(x | 0x 80); //El método para determinar la posición de visualización se especifica como "80H+código de dirección"
x "
}
/************************************ **** *************
Función: escribir datos (código de caracteres ASCII estándar) en el módulo LCD
Parámetros de entrada: y (como constante de caracteres )
****************************************** ******************/
void WriteData(carácter sin firmar y)
{
mientras( prueba ocupada () = = 1);
RS = 1; //Cuando //RS es alto y RW es bajo, se pueden escribir datos
RW = 0; p>
e = 0; //Establezca E bajo (según la Tabla 8-6, al escribir instrucciones, E es un pulso alto.
//Es para permitir que E salte de 0 a 1, así que primero configure "0".
P0 = y; //Envía los datos al puerto P0, es decir, escribe los datos al módulo LCD.
_no_();
_no_();
_no_(); ); // Ejecutar inactivo durante cuatro ciclos de la máquina para darle tiempo de reacción al hardware.
e = 1; //E se establece en nivel alto.
_no_();
_no_();
_no_(); ); // Ejecutar inactivo durante cuatro ciclos de la máquina para darle tiempo de reacción al hardware.
e = 0; //Cuando E salta del nivel alto al nivel bajo, el módulo LCD comienza a funcionar.
Comandos de línea
}
/*************************** *** *******************************
Función: Inicializa el modo de visualización LCD.
********************************************* ***** ********/
No válido
{
Delines(15); //Retraso 15 ms. Al escribir instrucciones, déle algo de tiempo a la pantalla LCD.
Tiempo de respuesta largo
escritura de instrucción (0x 38); //Configuración del modo de visualización: pantalla de 16 × 2, matriz de puntos de 5 × 7,
8 bits Interfaz de datos
Delines(5); //Retraso de 5 ms para darle al hardware algo de tiempo de reacción.
escribir instrucción(0x 38);
Dreins(5); //Retraso de 5 ms para darle al hardware algo de tiempo de reacción.
escribir instrucción(0x 38); //Tres veces seguidas para garantizar una inicialización exitosa.
Delines(5); //Retraso de 5 ms para darle al hardware algo de tiempo de reacción.
Comando de escritura (0x0c); //Configuración del modo de visualización: visualización encendida, sin cursor,
El cursor no parpadea.
Delines(5); //Retraso de 5 ms para darle al hardware algo de tiempo de reacción.
Comando de escritura (0x 06); //Configuración del modo de visualización: el cursor se mueve hacia la derecha, el personaje no se mueve
Mover
Delines (5) ); //Retraso de 5 ms para darle al hardware algo de tiempo de reacción.
escribir instrucción(0x 01); //Borrar instrucción de pantalla para borrar el contenido de la pantalla anterior.
Excepto...
Delines(5); //Retraso de 5 ms para darle al hardware algo de tiempo de reacción.
}
/************************************ ** ******************************
El siguiente es el programa de visualización de datos 1302.
********************************************* ***** *******************/
/****************** ******* *******************************
Función: Mostrar segundos
Parámetros de entrada:x
************************************ ******* ***********/
void DisplaySecond(carácter sin firmar x)
{
Sin firmar carácter I, j; ///j, k, k almacena decenas y un bit respectivamente.
I = x/10; //Obtiene el dígito de las decenas
j = x % 10; //Obtiene un poco
escribe la dirección (0x 49) ); //Escriba la dirección de visualización, que se mostrará en la fila 2 y la columna 7.
WriteData(number[I]); //Escribe cientos de constantes de caracteres en la pantalla LCD.
WriteData(digit[j]); //Escribe una constante de caracteres de diez dígitos en la pantalla LCD.
Delems(50); //Retraso de 1 ms para darle al hardware algo de tiempo de reacción.
}
/************************************ ** *******************
Función: mostrar minutos
Parámetros de entrada: x
* ************************************************* ** /
void muestra minutos (carácter sin signo x)
{
Caracteres sin signo I, j; //j, k decenas y unidades< / p>
I = x/10; //Obtener el dígito de las decenas
j = x % 10; //Obtener alguna
dirección de escritura(0x 46);/ / Escriba la dirección de visualización, que se mostrará en la fila 2 y la columna 7.
WriteData(number[I]); //Escribe cientos de constantes de caracteres en la pantalla LCD.
WriteData(digit[j]); //Escribe una constante de caracteres de diez dígitos en la pantalla LCD.
Drems(50); //Retraso de 1 ms para darle al hardware algo de tiempo de reacción.
}
/************************************ *******************
Función: visualización de horas
Parámetro de entrada: x
* * ************************************************** /
void muestra la hora (carácter sin signo x)
{
Carácter sin signo I, j //j, k dígitos de decenas y unidades< /p; >
I = x/10; //Obtener el dígito de las decenas
j = x % 10; //Obtener alguna
dirección de escritura(0x 43);/ /Escribir la dirección de visualización, que se mostrará en la fila 2 y la columna 7.
WriteData(number[I]); //Escribe cientos de constantes de caracteres en la pantalla LCD.
WriteData(digit[j]); //Escribe una constante de caracteres de diez dígitos en la pantalla LCD.
Drems(50); //Retraso de 1 ms para darle al hardware algo de tiempo de reacción.
}
/************************************ *******************
Función: mostrar fecha
Parámetro de entrada: x
* * ************************************************** /
void muestra el día (carácter sin signo x)
{
Caracteres sin signo I, j //j, k dígitos de decenas y unidades
I = x/10; //Obtener el dígito de las decenas
j = x % 10; //Obtener algo
escribir dirección(0x0c); Mostrar dirección y se mostrará en la fila 2 y columna 7.
WriteData(number[I]); //Escribe una constante de caracteres de diez dígitos en la pantalla LCD.
WriteData(digit[j]); //Escribe una constante de carácter de un dígito en la pantalla LCD.
Drems(50); //Retraso de 1 ms para darle al hardware algo de tiempo de reacción.
}
/************************************ *******************
Función: mostrar mes
Parámetro de entrada: x
* * ************************************************** /
void muestra el mes (carácter sin signo x)
{
Los caracteres sin signo I, j ///j, k, k almacenan diez Bits respectivamente; y bits.
I = x/10; //Obtener el dígito de las decenas
j = x % 10 //Obtener un poco
Escribir dirección (0x 09) ; //Escriba la dirección de visualización, que se mostrará en la fila 2 y la columna 7.
WriteData(number[I]); //Escribe una constante de caracteres de diez dígitos en la pantalla LCD.
WriteData(digit[j]); //Escribe una constante de carácter de un dígito en la pantalla LCD.
Drems(50); //Retraso de 1 ms para darle al hardware algo de tiempo de reacción.
}
/************************************ *******************
Función: Mostrar año
Parámetros de entrada: x
* * ************************************************** /
void muestra el año (carácter sin signo x)
{
Los caracteres sin signo I, j ///j, k, k almacenan diez bits respectivamente; y bits.
I = x/10; //Obtener el dígito de las decenas
j = x % 10 //Obtener un poco
Escribir dirección (0x 06) ; //Escriba la dirección de visualización, que se mostrará en la fila 2 y la columna 7.
WriteData(number[I]); //Escribe una constante de caracteres de diez dígitos en la pantalla LCD.
WriteData(digit[j]); //Escribe una constante de carácter de un dígito en la pantalla LCD.
Drems(50); //Retraso de 1 ms para darle al hardware algo de tiempo de reacción.
}
/************************************ *******************
Función función: función principal
************ ***************************************/
Administrador no válido( No válido)
{
Caracteres sin firmar segundos, minutos, horas, días, meses, años; //Almacenar las plántulas por separado
Minutos, horas, días, mes , año
Carácter sin firmar ReadValue//Datos de almacenamiento leídos desde 1302.
LcdInitiate(); //Inicializa la pantalla LCD.
escribir dirección(0x 01); //Escribe la dirección de visualización de la Fecha, que se muestra en la segunda columna de la fila 1.
WriteData("D"); //Escribe constantes de caracteres en la pantalla LCD.
WriteData("a"); //Escribe constantes de caracteres en la pantalla LCD.
WriteData("t"); //Escribe constantes de caracteres en la pantalla LCD.
WriteData(' e '); //Escribe constantes de caracteres en la pantalla LCD.
WriteData(":"); //Escribe constantes de caracteres en la pantalla LCD.
Escribir dirección (0x 08); //Escribe la dirección de visualización de los separadores de año y mes, que se muestran en la columna 9 y la fila 1.
WriteData("-"); //Escribe constantes de caracteres en la pantalla LCD.
escribir dirección(0x0b); //Escribe la dirección de visualización de los separadores de año y mes, que se muestran en 1 fila y 12 columnas.
WriteData("-"); //Escribe constantes de caracteres en la pantalla LCD.
escribir dirección(0x 45); //Escribe la dirección de visualización con separadores de hora y minutos, que se muestran en la segunda línea.
6 columnas
WriteData(":"); //Escribe constantes de caracteres en la pantalla LCD.
escribir dirección(0x 48); //Escribe la dirección de visualización del separador de minutos, minutos y segundos, que se muestra en la línea 2 y la línea 9.
Organizar
WriteData(":"); //Escribe constantes de caracteres en la pantalla LCD.
init _ ds 1302(); //Inicializar 1302
mientras(1)
{
valor de lectura = conjunto de lectura 1302( 0x 81); //Leer datos del segundo registro
Segundos = ((valor leído & 0x70)>& gt4)* 1(valor leído & 0x0F); leer.
Cambiar
DisplaySecond(segundos); //Mostrar segundos
valor de lectura = readset 1302(0x 83); //Leer del sub-registro< / p>
minuto =((valor leído & 0x70)>& gt4)* 1(valor leído & 0x0F); //Los datos serán leídos.
Cambiar
Mostrar minutos (minutos); //Mostrar puntos
valor de lectura = readset 1302(0x 85); /p>
hora =((valor leído &0x70)>>4)* 1(valor leído&0x0F);//Convierte los datos leídos en
cambio
DisplayHour(hora); //Mostrar hora
valor de lectura = readset 1302(0x 87); //Leer del subregistro
día =( (valor de lectura y 0x70) >& gt4)* 1(read value & 0x0F); //Convierte los datos leídos en
Change
DisplayDay( day); //Mostrar fecha
valor de lectura = readset 1302(0x 89); //Leer del subregistro
mes =((valor de lectura & 0x70)> & gt4)* 1(valor de lectura & 0x0F); /Se leerán los datos.
Cambiar
DisplayMonth(month); //Mostrar mes
valor de lectura = readset 1302(0x8d); //Leer del subregistro
año =((valor leído &0xf0)>>4)* 1(valor leído&0x0F);//Convierte los datos leídos en
cambio
p>DisplayYear(año); //Mostrar año
}
}