//********************************************************************************************************************
//Función que incrementa en uno, el contador que recoge las veces que el micro se ha despertado, almacenándolo en EEPROM.
//********************************************************************************************************************
BOOL Inc_CNT_Despiertes()
{
WORD_VAL Resultado;
BYTE Reintentos = 0;
//Lectura del valor actual e incremento.
Resultado.Val = (WORD)(Read_CNT_Despiertes()+1);
//Actualización del valor en memoria
do
{
EEPROM_WriteByte(Resultado.byte.LB, DIR_CNT_DESPIERTES);
EEPROM_WriteByte(Resultado.byte.HB, DIR_CNT_DESPIERTES+1);
Reintentos++;
}
while(((EEPROM_ReadByte(DIR_CNT_DESPIERTES)!=Resultado.byte.LB)||(EEPROM_ReadByte(DIR_CNT_DESPIERTES+1)!=Resultado.byte.HB))&&(Reintentos<3));
//Comprobación final..
if(Reintentos==3)
{
return FALSE;
}
else
{
return TRUE;
}
}
//********************************************************************************************************************
//Función que incrementa en uno, el contador que recoge el total de muestras tomadas, almacenándolo en EEPROM.
//********************************************************************************************************************
BOOL Inc_CNT_Muestras_Tomadas()
{
WORD_VAL Resultado;
BYTE Reintentos = 0;
//Lectura del valor actual e incremento de una unidad.
Resultado.Val = (WORD)(Read_CNT_Muestras_Tomadas()+1);
//Actualilzación del valor en memoria.
do
{
EEPROM_WriteByte(Resultado.byte.LB, DIR_CNT_MUESTRAS_TOMADAS);
EEPROM_WriteByte(Resultado.byte.HB, DIR_CNT_MUESTRAS_TOMADAS+1);
Reintentos++;
}
while(((EEPROM_ReadByte(DIR_CNT_MUESTRAS_TOMADAS)!=Resultado.byte.LB)||(EEPROM_ReadByte(DIR_CNT_MUESTRAS_TOMADAS+1)!=Resultado.byte.HB))&&(Reintentos<3));
//Comprobación final..
if(Reintentos==3)
{
return FALSE;
}
else
{
return TRUE;
}
}
//********************************************************************************************************************
//Función que pone a cero el contador de veces que el micro se ha despertado.
//********************************************************************************************************************
BOOL Reset_CNT_Despiertes()
{
WORD_VAL Resultado;
BYTE Reintentos = 0;
Resultado.Val = 0;
//Escritura del valor a 0
do
{
EEPROM_WriteByte(Resultado.byte.LB, DIR_CNT_DESPIERTES);
EEPROM_WriteByte(Resultado.byte.HB, DIR_CNT_DESPIERTES+1);
Reintentos++;
}
while(((EEPROM_ReadByte(DIR_CNT_DESPIERTES)!=Resultado.byte.LB)||(EEPROM_ReadByte(DIR_CNT_DESPIERTES+1)!=Resultado.byte.HB))&&(Reintentos<3));
//Comprobación final..
if(Reintentos==3)
{
return FALSE;
}
else
{
return TRUE;
}
}
//********************************************************************************************************************
//Función que pone a cero el contador de muestras tomadas.
//********************************************************************************************************************
BOOL Reset_CNT_Muestras_Tomadas()
{
WORD_VAL Resultado;
BYTE Reintentos = 0;
Resultado.Val = 0;
//Escritura del valor a 0
do
{
EEPROM_WriteByte(Resultado.byte.LB, DIR_CNT_MUESTRAS_TOMADAS);
EEPROM_WriteByte(Resultado.byte.HB, DIR_CNT_MUESTRAS_TOMADAS+1);
Reintentos++;
}
while(((EEPROM_ReadByte(DIR_CNT_MUESTRAS_TOMADAS)!=Resultado.byte.LB)||(EEPROM_ReadByte(DIR_CNT_MUESTRAS_TOMADAS+1)!=Resultado.byte.HB))&&(Reintentos<3));
//Comprobación final..
if(Reintentos==3)
{
return FALSE;
}
else
{
return TRUE;
}
}
//********************************************************************************************************************
//Función que obtiene el número de despiertes que debe realizar el micro, antes de efectuar una toma de muestra y
//almacenarla en memoria.
//********************************************************************************************************************
WORD Read_Despiertes_MAX()
{
WORD_VAL Resultado;
//Lectura en memoria del dato.
Resultado.byte.LB = EEPROM_ReadByte(DIR_DESPIERTES_POR_MEDIDA);
Resultado.byte.HB = EEPROM_ReadByte(DIR_DESPIERTES_POR_MEDIDA+1);
//Si el Resultado es 0xFFFF, significa que la memoria fué inicializada y por tanto el valor del contador lo asignaremos a 0.
if(Resultado.Val == 0xFFFF)
{
Resultado.Val = 0;
}
return Resultado.Val;
}
//********************************************************************************************************************
//Función que comprueba si el sistema está actualmente en modo de recuperación de la batería.
//********************************************************************************************************************
BOOL Modo_Recuperacion()
{
ESTADO_SISTEMA StatusSistema = INDETERMINADO;
BYTE Reintentos = 0;
//Lectura del contador de despiertes
do
{
StatusSistema = (ESTADO_SISTEMA)EEPROM_ReadByte(DIR_ESTADO_SISTEMA);
Reintentos++;
}while((StatusSistema==0xFF)&&(Reintentos<3));
if(Reintentos==3){return FALLO;}
//Valoración final
if(StatusSistema == NORMAL)
{
return NOK;
}
else if(StatusSistema == RECUPERACION)
{
return OK;
}
else
{
return ERROR;
}
}
/** EEPROM データ読み出し
* @param adr EEPROMアドレス
* @param[out] dt データ
* @param type データタイプ
* @return dt
**************************************************************************** */
void* PARA_ReadEepromData( uint16_t adr, void *dt, DATA_TYPE type )
{
uint8_t *dtp;
switch( type )
{
case DATA_TYPE_INT8:
EEPROM_ReadData( adr, (uint8_t*)dt, sizeof( int8_t ) );
break;
case DATA_TYPE_INT16:
EEPROM_ReadData( adr, (uint8_t*)dt, sizeof( int16_t ) );
break;
case DATA_TYPE_INT32:
EEPROM_ReadData( adr, (uint8_t*)dt, sizeof( int32_t ) );
break;
case DATA_TYPE_FLOAT:
EEPROM_ReadData( adr, (uint8_t*)dt, sizeof( float ) );
break;
case DATA_TYPE_STRING:
for( dtp = (uint8_t*)dt; ; dtp++, adr++ )
{
*dtp = EEPROM_ReadByte( adr );
if( *dtp == 0 )
break;
}
break;
default:
break;
}
return dt;
}
//********************************************************************************************************************
//Función que obtiene el valor de muestras máximas a acumular en memoria, antes de enviar toda la información vía modem.
//********************************************************************************************************************
WORD Read_Muestras_MAX_Envio_Modem()
{
WORD_VAL Resultado;
//Lectura en memoria del dato
Resultado.byte.LB = EEPROM_ReadByte(DIR_MUESTRAS_POR_ENVIO_MODEM);
Resultado.byte.HB = EEPROM_ReadByte(DIR_MUESTRAS_POR_ENVIO_MODEM+1);
//Si el Resultado es 0xFFFF, significa que la memoria fué inicializada y por tanto el valor del contador lo asignaremos a 0.
if(Resultado.Val == 0xFFFF)
{
Resultado.Val = 0;
}
return Resultado.Val;
}
//********************************************************************************************************************
//Función que obtiene el valor actual del contador de muestras tomadas.
//********************************************************************************************************************
WORD Read_CNT_Muestras_Tomadas()
{
WORD_VAL Resultado;
//Lectura en memoria del dato
Resultado.byte.LB = EEPROM_ReadByte(DIR_CNT_MUESTRAS_TOMADAS);
Resultado.byte.HB = EEPROM_ReadByte(DIR_CNT_MUESTRAS_TOMADAS+1);
//Si el Resultado es 0xFFFF, significa que la memoria fué inicializada y por tanto el valor del contador lo asignaremos a 0.
if(Resultado.Val == 0xFFFF)
{
Resultado.Val = 0;
}
return Resultado.Val;
}
void EEPROM_ReadNBytes(uint16_t var_eepromAddress_16, uint8_t *ptr_ramAddress_u8, uint16_t var_numOfBytes_u16)
{
while(var_numOfBytes_u16 != 0)
{
*ptr_ramAddress_u8 = EEPROM_ReadByte(var_eepromAddress_16);//Read a byte from EEPROM to RAM
var_eepromAddress_16++; //Increment the EEPROM Address
ptr_ramAddress_u8++; //Increment the RAM Address
var_numOfBytes_u16--; //Decrement NoOfBytes after Reading each Byte
}
}
void EEPROM_ReadString(uint16_t var_eepromAddress_u16, char *ptr_destStringAddress_u8)
{
char eeprom_data;
do
{
eeprom_data = EEPROM_ReadByte(var_eepromAddress_u16); //Read a byte from EEPROM to RAM
*ptr_destStringAddress_u8 = eeprom_data; //Copy the data into String Buffer
ptr_destStringAddress_u8++; //Increment the RAM Address
var_eepromAddress_u16++; //Increment the Eeprom Address
}while(eeprom_data!=0);
}
/***************************************************EEPROM*****************************************
Writes and Reads a character to and from EEPROM
*****************************************************TEST*****************************************/
void eeprom_test()
{
unsigned char eeprom_address=0x00, write_char = 'X', read_char;
UART_Printf("Connections SCL->P0.6 SDA->P0.7");
UART_Printf("Make connections and hit 'k' to test! ");
while(UART_RxChar()!='k');
UART_TxString("\n\rEeprom Write: "); //Print the message on UART
UART_TxChar(write_char); //Print the char to be written
EEPROM_WriteByte(eeprom_address,write_char); // Write the data at memoryLocation 0x00
UART_TxString(" Eeprom Read: "); //Print the message on UART
read_char = EEPROM_ReadByte(eeprom_address); // Read the data from memoryLocation 0x00
UART_TxChar(read_char);
}
/***************************************************EEPROM*****************************************
Writes and Reads a character to and from EEPROM
*****************************************************TEST*****************************************/
void eeprom_test()
{
unsigned char eeprom_address = 0x00, write_char = 'X', read_char;
for(write_char='A';write_char<='Z';write_char++) /* Eeprom Write and read A-Z */
{
UART_Printf("\n\rEeprom Write: %c ",write_char); //Print the message on UART
EEPROM_WriteByte(eeprom_address, write_char); // Write the data at memoryLocation 0x00
read_char = EEPROM_ReadByte(eeprom_address); // Read the data from memoryLocation 0x00
UART_Printf("Eeprom Read: %c",read_char); //Print the message on UART
}
while (1);
}
/* start the main program */
void main()
{
unsigned char eeprom_address=0x00, write_char = 'X', read_char;
/* Initialize the lcd before displaying any thing on the lcd */
LCD_Init(4,2,16);
while(1)
{
LCD_GoToLine(1); // Move the cursor to first line
LCD_DisplayString("Eeprom Write: "); //Display the message on first line
LCD_DisplayChar(write_char); //Display the char to be written
EEPROM_WriteByte(eeprom_address,write_char); // Write the data at memoryLocation 0x00
LCD_GoToLine(2); // Move the cursor to Second line
LCD_DisplayString("Eeprom Read: "); //Display the message on first line
read_char = EEPROM_ReadByte(eeprom_address); // Read the data from memoryLocation 0x00
LCD_DisplayChar(read_char); //Display the read data
}
}
//********************************************************************************************************************
//Función que pone al sistema del modo normal de funcionamiento.
//Acciones: Conexión del modem.
//********************************************************************************************************************
BOOL Desactivar_Modo_Recuperacion()
{
BYTE Reintentos = 0;
//Actualización en memoria del nuevo estado del sistema: Modo Normal.
do
{
EEPROM_WriteByte(NORMAL, DIR_ESTADO_SISTEMA);
Reintentos++;
}
while((EEPROM_ReadByte(DIR_ESTADO_SISTEMA)!=NORMAL)&&(Reintentos<3));
//Comprobación final..
if(Reintentos==3)
{
return FALSE;
}
else
{
return TRUE;
}
}
//********************************************************************************************************************
//Función que pone al sistema en modo de recuperación de la batería.
//Acciones: Desconexión del modem.
//********************************************************************************************************************
BOOL Activar_Modo_Recuperacion()
{
BYTE Reintentos = 0;
//Actualización en memoria del nuevo estado del sistema: Recuperación de batería.
do
{
EEPROM_WriteByte(RECUPERACION, DIR_ESTADO_SISTEMA);
Reintentos++;
}
while((EEPROM_ReadByte(DIR_ESTADO_SISTEMA)!=RECUPERACION)&&(Reintentos<3));
//Comprobación final..
if(Reintentos==3)
{
return FALSE;
}
else
{
return TRUE;
}
}
//********************************************************************************************************************
//Función que realiza el envío de toda la información almacenada en memoria, vía modem al centro servidor.
//********************************************************************************************************************
BOOL Enviar_Muestras_Modem()
{
WORD cntDireccion = 0;
WORD DirFinal = 0;
BYTE CadenaSplunk[100];
rtccFechaHora Timestamp;
SENSORES Muestra;
BYTE Checksum = 0;
BYTE Checksum_calc = 0;
//Obtenemos el límite hasta donde realizar la lectura de muestras
DirFinal = Siguiente_Direccion_Libre_EEPROM();
if(DirFinal> TAM_MEMORIA_EEPROM){return FALSE;}
//Lectura de cada uno de los datos de la memoria y envío por la UART
for(cntDireccion=DIR_BASE_MEDIDAS; cntDireccion<DirFinal; cntDireccion = (WORD)(cntDireccion + BYTES_POR_MEDIDA))
{
Timestamp.f.DiaMes = EEPROM_ReadByte(cntDireccion);
Timestamp.f.Mes = EEPROM_ReadByte(cntDireccion+1);
Timestamp.f.Ano = EEPROM_ReadByte(cntDireccion+2);
Timestamp.f.Hora = EEPROM_ReadByte(cntDireccion+3);
Timestamp.f.Minutos = EEPROM_ReadByte(cntDireccion+4);
Muestra.Temperatura =EEPROM_ReadByte(cntDireccion+5);
Muestra.Temperatura |=(WORD)(EEPROM_ReadByte(cntDireccion+6)<<8);
Muestra.Pluviometria =EEPROM_ReadByte(cntDireccion+7);
Muestra.Pluviometria |=(WORD)(EEPROM_ReadByte(cntDireccion+8)<<8);
Muestra.Vel_Aire =EEPROM_ReadByte(cntDireccion+9);
Muestra.Vel_Aire |=(WORD)(EEPROM_ReadByte(cntDireccion+10)<<8);
Muestra.Nivel_Bateria =EEPROM_ReadByte(cntDireccion+11);
Muestra.Nivel_Bateria |=(WORD)(EEPROM_ReadByte(cntDireccion+12)<<8);
Checksum = EEPROM_ReadByte(cntDireccion+13);
Checksum_calc = Calcula_Cheksum_Muestra(Timestamp, Muestra);
//Comprobación de la integridad de la muestra almacenada. Sólo si es correcta, se envía.
if(Checksum == Checksum_calc)
{
Formatear_Muestra_SvrSplunk(CadenaSplunk, Timestamp, Muestra);
UART2_Envia_Cadena((char*)CadenaSplunk);
}
Retardo(500);
}
return TRUE;
}
//********************************************************************************************************************
//Función que realiza el guardado de la muestra pasada como argumento, en la dirección indicada.
//Se guarda el timestamp asociado a la muestra.
//********************************************************************************************************************
BOOL Guarda_Muestra_EEPROM(SENSORES Muestra, WORD Direccion)
{
WORD_VAL Medida;
BYTE Reintentos = 0;
BYTE Suma = 0;
//Escritura de la TIMESTAMP///////////////////////
rtccFechaHora FechaHoraReloj = Lectura_FechaHora_Reloj();
Reintentos = 0;
do
{
EEPROM_WriteByte(FechaHoraReloj.f.DiaMes, Direccion);
EEPROM_WriteByte(FechaHoraReloj.f.Mes, Direccion+1);
EEPROM_WriteByte(FechaHoraReloj.f.Ano, Direccion+2);
EEPROM_WriteByte(FechaHoraReloj.f.Hora, Direccion+3);
EEPROM_WriteByte(FechaHoraReloj.f.Minutos, Direccion+4);
Reintentos++;
}
while(((EEPROM_ReadByte(Direccion)!=FechaHoraReloj.f.DiaMes)||(EEPROM_ReadByte(Direccion+1)!=FechaHoraReloj.f.Mes)||
(EEPROM_ReadByte(Direccion+2)!=FechaHoraReloj.f.Ano)||(EEPROM_ReadByte(Direccion+3)!=FechaHoraReloj.f.Hora)||
(EEPROM_ReadByte(Direccion+4)!=FechaHoraReloj.f.Minutos))&&(Reintentos<3));
//Si no se realizó correctamente, salimos.
if(Reintentos==3){return FALSE;}
//Escritura de la TEMPERATURA///////////////////////
Reintentos = 0;
do
{
Medida.Val = (WORD)Muestra.Temperatura;
EEPROM_WriteByte(Medida.byte.LB, Direccion+5);
EEPROM_WriteByte(Medida.byte.HB, Direccion+6);
Reintentos++;
}
while(((EEPROM_ReadByte(Direccion+5)!=Medida.byte.LB)||(EEPROM_ReadByte(Direccion+6)!=Medida.byte.HB))&&(Reintentos<3));
//Si no se realizó correctamente, salimos.
if(Reintentos==3){return FALSE;}
//Escritura de la PLUVIOMETRIA/////////////////////
Reintentos = 0;
do
{
Medida.Val = (WORD)Muestra.Pluviometria;
EEPROM_WriteByte(Medida.byte.LB, Direccion+7);
EEPROM_WriteByte(Medida.byte.HB, Direccion+8);
Reintentos++;
}
while(((EEPROM_ReadByte(Direccion+7)!=Medida.byte.LB)||(EEPROM_ReadByte(Direccion+8)!=Medida.byte.HB))&&(Reintentos<3));
//Si no se realizó correctamente, salimos.
if(Reintentos==3){return FALSE;}
//Escritura de la VELOCIDAD DEL AIRE///////////////
Reintentos = 0;
do
{
Medida.Val = (WORD)Muestra.Vel_Aire;
EEPROM_WriteByte(Medida.byte.LB, Direccion+9);
EEPROM_WriteByte(Medida.byte.HB, Direccion+10);
Reintentos++;
}
while(((EEPROM_ReadByte(Direccion+9)!=Medida.byte.LB)||(EEPROM_ReadByte(Direccion+10)!=Medida.byte.HB))&&(Reintentos<3));
//Si no se realizó correctamente, salimos.
if(Reintentos==3){return FALSE;}
//Escritura del NIVEL DEL LA BATERIA///////////////
Reintentos = 0;
do
{
Medida.Val = (WORD)Muestra.Nivel_Bateria;
EEPROM_WriteByte(Medida.byte.LB, Direccion+11);
EEPROM_WriteByte(Medida.byte.HB, Direccion+12);
Reintentos++;
}
while(((EEPROM_ReadByte(Direccion+11)!=Medida.byte.LB)||(EEPROM_ReadByte(Direccion+12)!=Medida.byte.HB))&&(Reintentos<3));
//Si no se realizó correctamente, salimos.
if(Reintentos==3){return FALSE;}
//CHECKSUM: DDMMYYHHMMTTTTPPPPVVVVBBBB + CHK
Suma = Calcula_Cheksum_Muestra(FechaHoraReloj, Muestra);
//Escritura de la suma de comprobación CHECKSUM///////////////
Reintentos = 0;
do
{
EEPROM_WriteByte(Suma, Direccion+13);
Reintentos++;
}
while((EEPROM_ReadByte(Direccion+13)!=Suma)&&(Reintentos<3));
//Si no se realizó correctamente, salimos.
if(Reintentos==3){return FALSE;}
//Si se llegó aquí, es que todo el proceso fué correcto.
return TRUE;
}
