¿Cómo guardar los parámetros operativos del microcontrolador Freescale mc9s12xs128 en EPROM o FASH?
Use Flash para simular EEPROM
Este programa utiliza el Flash en chip de la serie S08 Microcontrolador para simular EEPROM. Soluciona las limitaciones de la aplicación causadas por la falta de EEPROM en algunas computadoras de 8 bits. Este programa proporciona una función de inicialización y tres funciones funcionales. Antes de llamar a la función, el usuario debe llamar a la función de inicialización. Las tres funciones son escritura de bytes, lectura de bytes y borrado completo de EEPROM. Antes de llamar a esta función, el usuario debe asegurarse de que haya al menos 30 Bate de espacio en la pila.
Este programa hace referencia a "Uso de memoria FLASH para simular EEPROM en el microcontrolador HCS08" proporcionado por Freescale. Basado en el programa fuente, algunas funciones se simplifican y se reduce la cantidad de RAM. E intente utilizar el mecanismo de paginación para determinar la dirección EEPROM.
El direccionamiento de la dirección EEPROM de la función de interfaz consta de la dirección de la página y el desplazamiento dentro de la página. Es decir, la EEPROM definida por el usuario se divide en páginas con un tamaño de 256 bytes. La relación de conversión entre su dirección y la dirección FLASH es:
Dirección real FLASH = dirección inicial del espacio EEPROM + dirección de página × 256 + dirección de desplazamiento dentro de la página.
Cuando se utiliza EEPROM, el usuario solo necesita determinar la dirección relativa de los datos almacenados en la EEPROM. El prototipo de la función de interfaz es:
EEPROM_WRITE_DATA (datos, dirección de página, dirección de desplazamiento de página);
Char EEPROM_READ_DATA (dirección de página, dirección de desplazamiento de página);
1. Análisis y diseño del flujo del programa.
Dado que el microcontrolador de la serie S08 no puede realizar ninguna operación de lectura Flash durante la secuencia de escritura Flash, las instrucciones de escritura Flash deben colocarse en la RAM para su ejecución y todas las interrupciones enmascaradas deben desactivarse. El flujo del programa se muestra en la Figura 13-1-? .
Bytes escritos en /. Borrado completo del flujo del programa, lectura de bytes del flujo del programa
Figura 13-1-?
2. Código fuente del programa. Este programa fue compilado en el entorno de compilación heredado CodeWarrior 6.0.
/****************************************** ***********/
//Laboratorio conjunto de microcontroladores y DSP Freescale de la Universidad Tecnológica de Henan
//Nombre de archivo: flash_program.h
// CPU: MC9S08AW60
//Versión: v1.0
//Fecha: 12 de agosto de 2008
/ /Entorno de depuración: CodeWarrior 6.0
//Autor: Zeng Tao
//Descripción: archivo de encabezado, utilizado para guardar la configuración de inicialización de la EEPROM, los parámetros definidos por el usuario, los parámetros del compilador y otra información.
/****************************************** ***********/
# include & lthidef.h & gt
#Include "derivado.h"
# include & ltstdio.h & gt
/* * * * * * * * * * * *Instrucciones de programación flash (no cambiar)* * * * * * * * * * * * * * * *
#define BLACK_CHECK 0x05 //Instrucción vacía
#Define BITE_PROGRAM 0x20 //Instrucción de programación de bytes
#define BURST_PROGRAM 0x25 //Instrucción de programación rápida
p>
#define PAGE_ERASE 0x40 //Comando de borrado de página (1 página = 512 bytes)
#define MASS_ERASE 0x41 //Comando de borrado completo
/ * * * * * *Parámetros definidos por el usuario (personalizados según el modelo de MCU y el uso de memoria flash del usuario)* * * * * * * *
#Definir EEPROM _ Inicio _ dirección 0xe 000//Inicio de Dirección inicial del área EEPROM. Múltiplos de 512B
# definen EEPROM _ página _ num 8//página EEPROM. 1page=256B
#Define BUS_FREQUENCY 2000 //Frecuencia del bus. Unidad (kilohercios)
* * * * * * * * * * * * * * * * * * * *Parámetros relacionados con el compilador* * * * * * * * * * * * * * *
#Definir carácter sin signo INT8U // variable de byte sin signo. Dependiendo del compilador cambia. CodeWarrior predeterminado 6.0
# defineint16u unsigned short int//variable de palabra sin firmar. Dependiendo del compilador cambia. CodeWarrior 6.0 predeterminado
/* * * * * * * * * Prototipo de función API EEPROM * * * * * * * *
//Programa de inicialización. Esta función debe llamarse antes de utilizar la EEPROM. Se recomienda que los usuarios llamen a esto durante la inicialización del sistema.
void INIT _ EEPROM(void);
//Función de borrado de EEPROM. Borre todos los datos de la EEPROM.
void EEPROM _ ERASE(void);
//Función de escritura de bytes de EEPROM. Escribe un byte en el área especificada de EEPROM.
void EEPROM _ WRITE _ DATA(INT8U DATA, INT8U EEPROM_page, INT8U offset_address)
//Función de lectura de EEPROM. Lee el valor de retorno de los bytes almacenados en el área especificada en la función.
char EEPROM_READ_DATA(int 8u EEPROM_page, int 8u offset_address);
/****************** ******* ******Fin* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/************************************************ * *******/
//Laboratorio conjunto Freescale MCU y DSP de la Universidad Tecnológica de Henan
//Nombre del archivo: flash_program.c
/ / C P U: MC9S08AW60
//Versión: v1.0
//Fecha: 12 de agosto de 2008
//Entorno de depuración:CodeWarrior 6.0
//Autor: Zeng Tao
//Descripción: proporciona una función de inicialización y tres funciones para que los usuarios las llamen, sin parámetros modificables.
/****************************************** ***********/
#Contiene " flash_program.h "
const int 8u FLASH _ CODE[]= {//; /p>
0x45, 0x18, 0x26, //LDHX #$1826; la dirección FCMD se escribe como h: x
0xA6, 0x00, //LDA #$00 es el marcador de posición para el comando; .
0xF7, // STA, X; escribe el comando en el búfer de comandos FCMD.
0x5A, //DECX; puntero a FSTAT
0xF6, // LDA, X
0xAA, 0x80, //ORA #$80; p>
0xF7, // STA, X; Establecer FSTAT_FCBEF. Iniciar comando de escritura flash
0xF6, //LDA,X; esperar 3 ciclos de reloj (no eliminar este código)
0xF6, //LDA,X leer FSTAT< /p; >
0xA5, 0x30, //bit #$30
0x26, 0x05, //BNE *+6;
//Loop
0xF6, // LDA, X; espera a que finalice la operación de escritura.
0xA5, 0x40, //bit #$40
0x27, 0xFB, //BEQ *-3; saltar al bucle
//salir:< / p>
0x 81//RTS; retorno
};
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
#if frecuencia del bus>= 12000
void INIT _ EEPROM (void ){ fc div =(((BUS _ FRECUENCIA/(8 * 175)))| 0x 40)-1;}
#endif
#if frecuencia del bus& lt12000
void INIT _ EEPROM(void){ fc div =(BUS _ FREQUENCY/175)-1;}
#endif
* * * * * * * * * * * * * * * * * * * Función de escritura de bytes EEPROM * * * * * * * * * * * * * * * * * * * *
void EEPROM _ WRITE _ DATA( INT8U DATA, INT8U EEPROM_page, INT8U offset_address)
{
Dirección INT16U; // Dirección de escritura de almacenamiento
Código INT8U _ espacio[23] //Inicializar espacio de código
if(EEPROM_page>=EEPROM_PAGE_NUM) return; //Devolución de error de dirección, protege el código de usuario.
Dirección = offset_ADDRESS+EEPROM_page * 256+EEPROM_START_ADDRESS; //Conversión de dirección
(void)memcpy(code_space, FLASH_CODE, 23 // Copiar código de operación flash a RAM
code _ space[4] = BITE _ PROGRAM; //Modifica el marcador de posición del comando a un comando de escritura.
Deshabilitar interrupciones; //Desactivar interrupciones
if(FSTAT & 0x10){ //Borrar el indicador de error.
FSTAT = FSTAT | 0x 10;
}
_asm
{//Escribir inicialización
LDHX dirección;
Datos LDA;
STA, /Saltar a RAM para ejecución
}
Habilitar interrupciones //Activar interrupciones;
_ _ RESET _Watchdog();
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
char EEPROM _ READ _ DATA(INT8U EEPROM _ página, INT8U offset_address) {
Dirección entera corta sin signo; //Variable de dirección
char rusult//Variable de datos
Dirección = offset _ DIRECCIÓN+EEPROM _ página * 0x 10EEPROM _ INICIO _ DIRECCIÓN // Conversión de dirección
asm{
Dirección LDHX;
LDA, X; //Leer la dirección de la variable de datos
STA rusult
}
_ _ RESET _watchdog();
Return(ru sult); //return
}
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
void EEPROM_ERASE(void)
{
Dirección INT16U;
int 8u I; //Variable de bucle
INT8U; code _ space[23];
for(I = 0;i<(EEPROM_PAGE_NUM/2);I++){ //Borrado de página
Dirección = I * 0x 20EEPROM_START_ADDRESS;
(void)memcpy(code_space, FLASH_CODE, 23); //Copiar el código de operación flash a la RAM
Code_space[4] = page_erase //Copiar el espacio de comando El carácter es cambiado al comando de borrado.
Deshabilitar interrupciones; //Desactivar interrupciones
if(FSTAT & 0x10){ //Borrar el indicador de error.
FSTAT = FSTAT | 0x 10;
}
_asm
{
Dirección LDHX; Borrar caché de escritura de dirección
STA, X;
TSX;
JSR 3, x //Saltar a RAM para ejecución
}
Habilitar interrupciones; //Activar interrupciones
_ _ RESET _Watchdog();
}
}
/***************************Fin* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/********************** *** **************************/
//Copyright (c) Universidad Tecnológica de Henan
//Nombre del archivo: mian.c
// C P U:MC9S08AW60
//Versión: v1.0
//Fecha: 12 de agosto , 2008
//Entorno de depuración: CodeWarrior 6.0
//Autor: Zeng Tao
//Descripción: Prueba del programa EEPROM de simulación Flash.
/****************************************** ************/
# include & lthidef.h & gt
#Include "derivado.h"
#Include " flash_program.h "
Principal no válido (no válido){
Temperatura de carbonización;
PTADD = 0XFF
INIT_EEPROM () ; //Inicializa el registro de control de Flash.
Hacer {
EEPROM_WRITE_DATA(88, 0, 0); //Escribir un byte.
temp=EEPROM_READ_DATA(0, 0); //Leer un byte
} while(temp!=88);//Escribir nuevamente si la escritura no tiene éxito.
PTAD _ ptad 0 = 1;
Hacer {
EEPROM _ ERASE()
}mientras(EEPROM_READ_DATA(0, 0)! = 0x ff); // Borrar Flash
PTAD _ ptad 1 = 1;
for(;;)_ _ RESET _ WATCHDOG();
}