int main(void)
{
char arg[50];
char tstr[200];
int ret;
TMR_Init();
gettimeofday(&nowtime, NULL);
hdl[0] = TMR_SetTimer(100, 1, pfnCallback1, NULL );
//printf("hdl[0]=%d\n", hdl[0]);
hdl[1] = TMR_SetTimer(100, 1, pfnCallback2, NULL);
// printf("hdl[1]=%d\n", hdl[1]);
hdl[2] = TMR_SetTimer(100, 1, pfnCallback2, NULL );
// printf("hdl[2]=%d\n", hdl[2]);
// hdl[3] = TMR_SetTimer(10, pfnCallback1, NULL, );
// hdl[4] = TMR_SetTimer(10, pfnCallback1, NULL,);
// hdl[5] = TMR_SetTimer(10, pfnCallback1, NULL,);
// hdl[6] = TMR_SetTimer(10, pfnCallback1, NULL,);
// hdl[7] = TMR_SetTimer(10, pfnCallback1, NULL, 0);
// hdl[8] = TMR_SetTimer(10, pfnCallback1, NULL, 0);
// hdl[9] = TMR_SetTimer(10, pfnCallback1, NULL, 0);
// hdl[10] = TMR_SetTimer(10, pfnCallback1, NULL, 0);
// hdl[11] = TMR_SetTimer(10, pfnCallback1, NULL, 0);
// hdl[12] = TMR_SetTimer(10, pfnCallback1, NULL, 0);
// hdl[13] = TMR_SetTimer(10, pfnCallback1, NULL, 0);
while(1)
{
if (call_cnt[1] >= 50)
{
//TMR_PauseTimer(hdl[0]);
//TMR_CancleTimer(hdl[0]);
TMR_Shutdown();
printf("p1 count : %d\n", call_cnt[1]);
printf("p2 count : %d\n", call_cnt[2]);
break;
}
if(call_cnt[0] >= 200)
{
// get_format_time(tstr);
// ret = TMR_Shutdown();
// printf("main: %s TMR_Shutdown, ret=%d\n", tstr, ret);
// call_cnt++;
printf("p1 count : %d\n", call_cnt[1]);
printf("p2 count : %d\n", call_cnt[2]);
break;
}
}
uint32_t errornum = TMR_ReturnErrorNum();
printf("%d, %ld\n", call_cnt[0], errornum, (float)errornum / call_cnt[0] *100);
return 0;
}
// ---------------------------------------------------------------------------
// TCP_RetransmitSrvTcpMsg : ReEnviar mensaje SrvTcp por puerto TCP
//
UINT8 TCP_RetransmitSrvTcpMsg(UINT8 SocketIdx)
{
UINT16 i;
UINT16 len;
UINT8 TimerGetStateId;
UINT8* pTxBuffer;
UINT8 bTmpToken;
UINT8 BufLen;
if (tcp_getstate(TcpSockSrv[SocketIdx].TcpSrvTcpSoch) != TCP_STATE_CONNECTED){
return (-1);
}
if (tcp_checksend(TcpSockSrv[SocketIdx].TcpSrvTcpSoch) < 0)
{
TcpWhileFlag = 0x01;
TimerGetStateId = TMR_SetTimer ( TCP_WAITFORSEND_TOUT , OS_NOT_PROC, TCP_StopWhileProc, FALSE);
while (tcp_checksend(TcpSockSrv[SocketIdx].TcpSrvTcpSoch) < 0)
{
if (!TcpWhileFlag) return (-1); // Cuando vence el timer se resetea TcpWhileFlag
}
TMR_FreeTimer ( TimerGetStateId );
}
bTmpToken = TcpSockSrv[SocketIdx].BufferToken;
if (MemGetBufferPtr( bTmpToken , (void**)(&pTxBuffer) ) != OK ){
(void)MemFreeBuffer (bTmpToken); // Liberar por las dudas ? ABR: control de errores
return(-1);
}
BufLen = *pTxBuffer;
pTxBuffer++;
len = 0;
for( i=0 ; i < BufLen ; i++ ){
net_buf[TCP_APP_OFFSET+len] = *pTxBuffer;
pTxBuffer++;
len++;
}
if(tcp_send(TcpSockSrv[SocketIdx].TcpSrvTcpSoch, &net_buf[TCP_APP_OFFSET], NETWORK_TX_BUFFER_SIZE - TCP_APP_OFFSET, len) == len) {
DEBUGOUT("TCP: bytes reply sent!\r\n");
#if DEBUG_AT(DBG_LEVEL_2)
if (SYS_ConfigParam.DebugLevel>= DBG_LEVEL_2)
{
(void)sprintf((char *)udp_buf,"TCP_Sent Len: %d, IP:%d \n",
len,
(BYTE)TcpSockSrv[SocketIdx].SlaveIpAddress);
udp_data_to_send = TRUE;
}
#endif
}
else {
DEBUGOUT("TCP: error occured while trying to send data!\r\n");
}
return (1);
}
//--------------------------------------------------------------------------------------
//-- Funcion de Reinicialización en caso de fallas
//
void MTS_ReInit (void)
{
CurrentProcessState [PROC_MTS] = (EVENT_FUNCTION*)MTSProc_IDLE;
// Iniciar un timer para enviar comando..
MTS_WaitAnswerTimerId = TMR_SetTimer ( TMR_MTS_RESETLINKWAIT , PROC_MTS, 0x00, FALSE);
}
interrupt void near SCI0_isr (void){
RTU_tmp_var = RTU_SCISR1;
if (RTU_tmp_var & SCI1SR1_RDRF_MASK){ // RX interrupt
if (RTU_rx_bytecount){
*RTU_frame_to_rx = RTU_SCIDRL;
if (!RTU_RxByteIdx){
RTU_TimerID = TMR_SetTimer ( 30 , PROC_RTU, 0x00, FALSE);
}
//ABR if ( (RTU_RxByteIdx == 0x06) && ( pModRtuInMsg->FC == 16) ){ // FC = WR_MUL
// RTU_rx_bytecount = *RTU_frame_to_rx; // Byte count
// RTU_rx_bytecount += 0x03; // CRC + bound effects
// }
RTU_RxByteIdx++;
RTU_frame_to_rx++;
RTU_rx_bytecount--;
if (!RTU_rx_bytecount){
RTU_SCICR2 &= ~(SCI1CR2_RE_MASK) ; // Rx Disable
RTU_SCICR2 &= ~(SCI1CR2_RIE_MASK); // Rx Interrupt Disable
TMR_FreeTimer (RTU_TimerID);
//ABR PutEventMsg (EVT_232_RXMSG, PROC_MODRTU, OS_NOT_PROC, 0x00);
//ABR RTU_ReceiveFrame (8, (UINT8 *)pModRtuInMsg);
}
}
else{
RTU_tmp_var = RTU_SCIDRL; // Flush buffer
}
return;
}
if (RTU_tmp_var & SCI1SR1_TDRE_MASK){ // TX interrupt
// else{
if (!RTU_tx_bytecount){
// RTU_SCICR2 &= ~(SCI1CR2_SCTIE_MASK); // Tx Interrupt Disable
RTU_SCICR2 &= ~(SCI1CR2_TE_MASK ); // Tx Disable
RTU_SCICR2 &= ~(SCI1CR2_TCIE_MASK); // TxC Interrupt Disable
//ABR PutEventMsg (EVT_232_TXMSG, PROC_MODRTU, OS_NOT_PROC, 0x00);
}
else{
RTU_SCIDRL = *RTU_frame_to_tx;
RTU_frame_to_tx++;
RTU_tx_bytecount--;
}
return;
}
RTU_SCICR2 &= ~(SCI1CR2_RE_MASK) ; // Rx Disable
RTU_SCICR2 &= ~(SCI1CR2_RIE_MASK); // Rx Interrupt Disable
RTU_SCICR2 &= ~(SCI1CR2_TE_MASK ); // Tx Disable
TMR_FreeTimer (RTU_TimerID);
//ABR RTU_ReceiveFrame (8, (UINT8 *)pModRtuInMsg);
}
void f_SerialSendRequest (void)
{
RS485_A_RE_ = 1; // TX Mode
RS485_A_DE = 1; // TX Mode
SCI_tmp_var = SCIDRL; // Flush buffer
SCI_tmp_var = SCISR1; // Clear pending flag
LED_RED_ON;
switch (SYS_ConfigParam.InvCode){
case (PROC_SIEMENS ):
SCI_tx_bytecount = SIE_COMMON_LGE + 1;
frame_to_tx = (UINT8 *)(&(pSiemensOutMsg->LGE));
SCICR2 |= SCI1CR2_TE_MASK ; // Tx Enable
SCIDRL = pSiemensOutMsg->IniFlag;
break;
case (PROC_SIE_MASTERDRV ):
SCI_tx_bytecount = SIE_COMMON_LGE + 1;
frame_to_tx = (UINT8 *)(&(pSieMasterDrvOutMsg->LGE));
SCICR2 |= SCI1CR2_TE_MASK ; // Tx Enable
SCIDRL = pSieMasterDrvOutMsg->IniFlag;
break;
/*
case (PROC_HITACHI ):
SCI_tx_bytecount = ((pHitachiOutMsg->TxLen) - 1);
frame_to_tx = (UINT8 *)(&(pHitachiOutMsg->Addr[0]));
SCICR2 |= SCI1CR2_TE_MASK ; // Tx Enable
SCIDRL = pHitachiOutMsg->IniFlag;
break;
case (PROC_HIT_SJ300 ):
SCI_tx_bytecount = ((pHitSJ300OutMsg->TxLen) - 1);
frame_to_tx = (UINT8 *)(&(pHitSJ300OutMsg->Addr[0]));
SCICR2 |= SCI1CR2_TE_MASK ; // Tx Enable
SCIDRL = pHitSJ300OutMsg->IniFlag;
break;
*/
default:
MON_ResetBoard();
break;
}
// SCICR2 |= SCI1CR2_SCTIE_MASK; // Tx Interrupt Enable
SCICR2 |= SCI1CR2_TCIE_MASK; // TxC Interrupt Enable
SCI_TX_TimerID = TMR_SetTimer ( TMR_TX_TIMEOUT , PROC_SERIAL, 0x00, FALSE);
FirstEventInCurrentState = (EVENT_FUNCTION*)SerialProc_TRANSMITING;
return;
}
void f_SCIATxFrame (void)
{
TMR_FreeTimer (SCIA_TX_TimerID);
SCIA_TX_TimerID = 0xFF;
// Pasar a modo recepción..
RS485_A_DE = 0; // RX Mode
RS485_A_RE_ = 0; // RX Mode
LED_GREEN_OFF;
LED_RED_ON;
if ( SCIA_StateFlags & FLG_TX_COMMAND ) // comando transmitido, entonces esperar respuesta
{
SCIA_StateFlags &= ~FLG_TX_COMMAND;
SCIA_RxOffset = SCIA_TxOffset; // Tomar el mismo offset para escribir la respuesta
// Recuperar puntero al buffer de transmisión que se reutilizará para recepción
SCIA_CurrentRxToken = SCIA_CurrentTxToken;
if ( MemGetBufferPtr( SCIA_CurrentRxToken , (void**)&(SCIA_FrameToRx)) != OK ){
// ABR: control de errores
PutEventMsg (EVT_SCI_TXERR, SCIA_TargetProc, PROC_SCIA, SCIA_CurrentTxToken);
StatisticData.SerialStat.MsgTxErr++;
//Volver a IDLE
FirstEventInCurrentState = (EVENT_FUNCTION*)SCIAProc_IDLE;
return;
}
// Preparar para leer la misma cantidad de bytes que se envió en el comando
if ( MemGetUsedLen(SCIA_CurrentRxToken, &SCIA_RxByteCount) != OK) // Bytes a recibir
MON_ResetIfNotConnected(0x14); // Error de SW, Reset (TODO: revisar acciones a tomar)
SCIA_RxByteIdx = 0x00; // Indice contador de Bytes recibidos
SCIA_FrameToRx += SCIA_RxOffset;
m_RxMsgLen = 0x00;
SCIA_TmpVar = SCIA_SCISR1; // Clear pending flag
SCIA_TmpVar = SCIA_SCIDRL; // Flush buffer
SCIA_SCICR2 |= SCI1CR2_RE_MASK ; // Rx Enable
SCIA_SCICR2 |= SCI1CR2_RIE_MASK; // Rx Interrupt Enable
SCIA_RX_TimerID = TMR_SetTimer ( SCIA_TMR_RX_TIMEOUT , PROC_SCIA, 0x00, FALSE);
FirstEventInCurrentState = (EVENT_FUNCTION*)SCIAProc_RECEIVING;
}
else
{
FirstEventInCurrentState = (EVENT_FUNCTION*)SCIAProc_IDLE;
}
StatisticData.SerialStat.MsgTxOk++;
PutEventMsg (EVT_SCI_TXMSG, SCIA_TargetProc, PROC_SCIA, SCIA_CurrentTxToken );
}
//--------------------------------------------------------------------------------------
//-- Funcion de Inicialización
//
void MTS_Init (void)
{
// Las direcciones son WORD, que ya están grabada en EEPROM con formato LSB:MSB
// eeprom_read_buffer(EE_ADDR_DNP_SLAVE, (UINT8 *)&MTS_wRemoteAddr, 2);
// eeprom_read_buffer(EE_ADDR_DNP_MASTER, (UINT8 *)&MTS_wLocalAddr, 2);
SCIA_Init(); // Driver de comunicación serie (SCI1)
MTS_CmdIdx = 0x00;
// Iniciar un timer para enviar comando..
MTS_WaitAnswerTimerId = TMR_SetTimer ( TMR_MTS_RESETLINKWAIT , PROC_MTS, 0x00, FALSE);
}
void f_SerialTxFrame (void)
{
TMR_FreeTimer (SCI_TX_TimerID);
LED_RED_OFF;
StatisticData.SerialStat.MsgTxOk++;
SCI_TxErrAcc = 0x00;
LED_GREEN_ON;
switch (SYS_ConfigParam.InvCode){
case (PROC_SIEMENS ):
SCI_rx_bytecount = SIE_COMMON_LGE + 2;
frame_to_rx = (UINT8 *)(&(pSiemensInMsg->IniFlag));
break;
case (PROC_SIE_MASTERDRV ):
SCI_rx_bytecount = SIE_COMMON_LGE + 2;
frame_to_rx = (UINT8 *)(&(pSieMasterDrvInMsg->IniFlag));
break;
/*
case (PROC_HITACHI ):
SCI_rx_bytecount = pHitachiOutMsg->RxLen;
frame_to_rx = (UINT8 *)(&(pHitachiInMsg->IniFlag));
break;
case (PROC_HIT_SJ300 ):
SCI_rx_bytecount = pHitSJ300OutMsg->RxLen;
frame_to_rx = (UINT8 *)(&(pHitSJ300InMsg->IniFlag));
break;
*/
default:
MON_ResetBoard();
break;
}
// SCI_RxWaitFirst = 0x01;
RS485_A_DE = 0; // RX Mode
RS485_A_RE_ = 0; // RX Mode
SCI_tmp_var = SCISR1; // Clear pending flag
SCI_tmp_var = SCIDRL; // Flush buffer
SCICR2 |= SCI1CR2_RE_MASK ; // Rx Enable
SCICR2 |= SCI1CR2_RIE_MASK; // Rx Interrupt Enable
SCI_RX_TimerID = TMR_SetTimer ( TMR_RX_TIMEOUT , PROC_SERIAL, 0x00, FALSE);
FirstEventInCurrentState = (EVENT_FUNCTION*)SerialProc_RECEIVING;
}
// ---------------------------------------------------------------------------
// TCP_SendSrvTcpMsg : Enviar mensaje SrvTcp por puerto TCP
//
//UINT8 TCP_SendSrvTcpMsg (void)
UINT8 TCP_SendSrvTcpBuff(UINT8 * Buff, UINT16 BufLen, UINT8 SocketIdx)
{
UINT16 i;
UINT16 len;
UINT8 TimerGetStateId;
if (tcp_getstate(TcpSockSrv[SocketIdx].TcpSrvTcpSoch) != TCP_STATE_CONNECTED){
return 0x01;
}
if (tcp_checksend(TcpSockSrv[SocketIdx].TcpSrvTcpSoch) < 0)
{
TcpWhileFlag = 0x01;
TimerGetStateId = TMR_SetTimer ( TCP_WAITFORSEND_TOUT , OS_NOT_PROC, TCP_StopWhileProc, FALSE);
while (tcp_checksend(TcpSockSrv[SocketIdx].TcpSrvTcpSoch) < 0)
{
if (!TcpWhileFlag) return 0x01; // Cuando vence el timer se resetea TcpWhileFlag
}
TMR_FreeTimer ( TimerGetStateId );
}
len = 0;
for( i=0 ; i < BufLen ; i++ ){
net_buf[TCP_APP_OFFSET+len] = *Buff;
Buff++;
len++;
}
if(tcp_send(TcpSockSrv[SocketIdx].TcpSrvTcpSoch, &net_buf[TCP_APP_OFFSET], NETWORK_TX_BUFFER_SIZE - TCP_APP_OFFSET, len) == len) {
DEBUGOUT("TCP: bytes reply sent!\r\n");
#if DEBUG_AT(DBG_LEVEL_2)
if (SYS_ConfigParam.DebugLevel>= DBG_LEVEL_2)
{
(void)sprintf((char *)udp_buf,"TCP_Sent Len: %d, IP:%d \n",
len,
(BYTE)TcpSockSrv[SocketIdx].SlaveIpAddress);
udp_data_to_send = TRUE;
}
#endif
}
else {
DEBUGOUT("TCP: error occured while trying to send data!\r\n");
}
return 0x00;
}
// ---------------------------------------------------------------------------
// Enviar mensaje por puerto TCP con informacion de CliTcp
//
UINT8 TCP_SendCliTcpBuff(UINT8 * Buff, UINT16 BufLen)
{
UINT16 i;
UINT16 len;
UINT8 TimerGetStateId;
// CliTcpIpChar[0] = 192;
// CliTcpIpChar[1] = 168;
// CliTcpIpChar[2] = 0;
// CliTcpIpChar[3] = 32;
if (tcp_getstate(TcpCliTcpSoch) != TCP_STATE_CONNECTED){
if ( tcp_connect (TcpCliTcpSoch, CliTcpIp, (UINT16)(CliTcpSockPort), 0 ) == (-1)){ // (UINT16)(DNP_LOCAL_PORT)
return 0x01;
}
}
if (tcp_checksend(TcpCliTcpSoch) < 0)
{
TcpWhileFlag = 0x01;
TimerGetStateId = TMR_SetTimer ( TCP_WAITFORSEND_TOUT , OS_NOT_PROC, TCP_StopWhileProc, FALSE);
while (tcp_checksend(TcpCliTcpSoch) < 0)
{
if (!TcpWhileFlag) return 0x01; // Cuando vence el timer se resetea TcpWhileFlag
}
TMR_FreeTimer ( TimerGetStateId );
}
len = 0;
for( i=0 ; i < BufLen ; i++ ){
net_buf[TCP_APP_OFFSET+len] = *Buff;
Buff++;
len++;
}
if(tcp_send(TcpCliTcpSoch, &net_buf[TCP_APP_OFFSET], NETWORK_TX_BUFFER_SIZE - TCP_APP_OFFSET, len) == len) {
DEBUGOUT("TCP: bytes reply sent!\r\n");
}
else {
DEBUGOUT("TCP: error occured while trying to send data!\r\n");
}
return 0x00;
}
//--------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------
//---------- estado : TOTRANSMIT ------------------------------------------------------------
//--------------------------------------------------------------------------------------------
//
void f_SCIAToTxTimeout (void)
{
SCIA_TX_TimerID = 0xFF;
SCIA_TmpVar = SCIA_SCIDRL; // Flush buffer
SCIA_TmpVar = SCIA_SCISR1; // Clear pending flag
SCIA_FrameToTx += SCIA_TxOffset;
SCIA_SCIDRL = *SCIA_FrameToTx;
SCIA_TxByteCount--;
SCIA_FrameToTx++;
// SCIA_SCICR2 |= SCI1CR2_SCTIE_MASK; // Tx Interrupt Enable
SCIA_SCICR2 |= SCI1CR2_TCIE_MASK; // TxC Interrupt Enable
SCIA_SCICR2 |= SCI1CR2_TE_MASK ; // Tx Enable
SCIA_TX_TimerID = TMR_SetTimer ( SCIA_TMR_TX_TIMEOUT , PROC_SCIA, 0x00, FALSE);
FirstEventInCurrentState = (EVENT_FUNCTION*)SCIAProc_TRANSMITING;
}
/********************************************************************************************
* Atención al evento de mensaje transmitido. (para modo RS232, siempre esta en IDLE) *
* Responde a los mensajes: *
* - EVT_SCI_TXMSG : Mensaje transmitido OK. *
* Se envía evento EVT_SCI_TXMSG al proceso que requirió la transmisión del mensaje con el *
* token del TxBuffer como parámetro. *
* En caso de haber sido una transmisión de comando (EVT_SCI_TXCMD) además se realizan los *
* preparativos para recibir la respuesta en el mismo buffer, con el mismo offset y len *
********************************************************************************************/
void f_SCIAIdleFrameTx (void)
{
LED_GREEN_OFF;
LED_RED_ON;
StatisticData.SerialStat.MsgTxOk++;
if ( SCIA_StateFlags & FLG_TX_COMMAND ) // comando transmitido, entonces esperar respuesta
{
SCIA_StateFlags &= ~FLG_TX_COMMAND;
SCIA_RxOffset = SCIA_TxOffset; // Tomar el mismo offset para escribir la respuesta
// Recuperar puntero al buffer de transmisión que se reutilizará para recepción
SCIA_CurrentRxToken = SCIA_CurrentTxToken;
if ( MemGetBufferPtr( SCIA_CurrentRxToken , (void**)&(SCIA_FrameToRx)) != OK ){
// ABR: control de errores
PutEventMsg (EVT_SCI_TXERR, SCIA_TargetProc, PROC_SCIA, SCIA_CurrentTxToken);
return;
}
// Preparar para leer la misma cantidad de bytes que se envió en el comando
if ( MemGetUsedLen(SCIA_CurrentRxToken, &SCIA_RxByteCount) != OK) // Bytes a recibir
MON_ResetIfNotConnected(0x14); // Error de SW, Reset (TODO: revisar acciones a tomar)
// Preparar para leer la maxima cantidad de bytes que soporta el buffer
//SCIA_RxByteCount = (MEM_MAX_BUF_LEN - SCIA_RxOffset);
SCIA_RxByteIdx = 0x00; // Indice contador de Bytes recibidos
SCIA_FrameToRx += SCIA_RxOffset;
m_RxMsgLen = 0x00;
SCIA_TmpVar = SCIA_SCISR1; // Clear pending flag
SCIA_TmpVar = SCIA_SCIDRL; // Flush buffer
SCIA_SCICR2 |= SCI1CR2_RE_MASK ; // Rx Enable
SCIA_SCICR2 |= SCI1CR2_RIE_MASK; // Rx Interrupt Enable
// Si es espera de respuesta a comando, el timer se inicializa aquí aún para RS232
SCIA_RX_TimerID = TMR_SetTimer ( SCIA_TMR_RX_TIMEOUT , PROC_SCIA, 0x00, FALSE);
}
PutEventMsg (EVT_SCI_TXMSG, SCIA_TargetProc, PROC_SCIA, SCIA_CurrentTxToken );
}
UINT8 IIC_SendMsg (UINT8 SlaveAddress, UINT8 LenTx, UINT8 LenRx)
{
MasterRxFlag = FALSE;
TxPacketpositionptr = &TxPacket[0]; // apuntar al primer elemento de TxPacket
TxBufferemptyflag = FALSE;
TxPacketendptr = &TxPacket[(LenTx-1)]; // apuntar al último elemento a transmitir
CurrentSlave = SlaveAddress;
TxMsgLen = LenTx;
RxMsgLen = LenRx;
IIC_TransferState = IIC_TRANSFERING; // Estado = Transfiriendo
TxTimerID = TMR_SetTimer ( 500 , PROC_IIC, f_IICTimeout, FALSE);
while(IBSR & IBB){ // mientras el bus IIC esté ocupado
if (IIC_TransferState != IIC_TRANSFERING)
return ERROR;
}
IBCR = (IBEN|IBIE|MSSL|TXRX); // grab bus - start condition initiated
IBDR = SlaveAddress; // address the slave
while (IIC_TransferState == IIC_TRANSFERING){
REFRESH_WATCHDOG;
}
if ( IIC_TransferState == IIC_TX_OK ){
TMR_FreeTimer (TxTimerID); // anular el timer de supervisión de la transmisión
if (!RxMsgLen)
return OK;
else
return (IIC_ReceiveMsg (CurrentSlave, RxMsgLen)); // ####################
}
IIC_Init();
return ERROR;
}
void f_SCIBReceiveMsg (void)
{
// Si hay recepción en curso rechazar el requerimiento.
if ( SCIB_RxByteCount ) {
PutEventMsg (SCIB_EVT_SCI_RXERR, SCIB_TargetProc, PROC_SCIB, SCIB_CurrentTxToken);
return;
}
if (SCIB_ConfigByte & CFG_SCI_PHYMODE_MASK){ // modo RS485
RS485_B_RE_ = 0; // RX Mode
RS485_B_DE = 0; // RX Mode
}
// Offset donde escribir la respuesta, en la parte alta del parámetro
SCIB_RxOffset = (UINT8)((CurrentMsg.Param)>>8);
// El token del buffer está en la parte baja del parámetro del mensaje
SCIB_CurrentRxToken = (UINT8)CurrentMsg.Param;
(void)MemGetBufferPtr ( SCIB_CurrentRxToken, (void**) &(SCIB_FrameToRx));
SCIB_FrameToRx += SCIB_RxOffset;
if ( MemGetUsedLen(SCIB_CurrentRxToken, &SCIB_RxByteCount) != OK) // Bytes a recibir
MON_ResetIfNotConnected(0x22); // Error de SW, Reset (TODO: revisar acciones a tomar)
SCIB_RxByteIdx = 0x00; // Indice contador de Bytes recibidos
m_SCIB_RxMsgLen = 0x00;
SCIB_TmpVar = SCIB_SCISR1; // Clear pending flag
SCIB_TmpVar = SCIB_SCIDRL; // Flush buffer
SCIB_SCICR2 |= SCI1CR2_RE_MASK ; // Rx Enable
SCIB_SCICR2 |= SCI1CR2_RIE_MASK; // Rx Interrupt Enable
if (SCIB_ConfigByte & CFG_SCI_PHYMODE_MASK) // modo RS485
{
if (!(SCIB_StateFlags & FLG_RX_RELOAD)) // Si no hay que esperar indefinidamente
SCIB_RX_TimerID = TMR_SetTimer ( SCIB_TMR_RX_TIMEOUT , PROC_SCIB, 0x00, FALSE);
FirstEventInCurrentState = (EVENT_FUNCTION*)SCIBProc_RECEIVING;
}
return;
}
///////////////////////////////////////////////////////////////////////////////
// Funciones Auxiliares del Proceso
///////////////////////////////////////////////////////////////////////////////
//
//-----------------------------------------------------------------------------
// GPIO_Init : inicializacion de variables del proceso
//-----------------------------------------------------------------------------
//
void PIO_Init(void)
{
GpioControl.CurrentVal = GIO_GetInpVal();
GpioControl.PreviousVal = GpioControl.CurrentVal ;
GpioControl.CfgIo[0]= ( CFG_DIO_TRIGGER_LEVEL | CFG_DIO_REPORT_EVENT | CFG_DIO_REPORT_PERIODIC_MESSAGE );
GpioControl.CfgIo[1]= ( CFG_DIO_TRIGGER_LEVEL | CFG_DIO_REPORT_EVENT | CFG_DIO_REPORT_PERIODIC_MESSAGE );
GpioControl.CfgIo[2]= ( CFG_DIO_TRIGGER_LEVEL | CFG_DIO_REPORT_EVENT | CFG_DIO_REPORT_PERIODIC_MESSAGE );
GpioControl.CfgIo[3]= ( CFG_DIO_TRIGGER_LEVEL | CFG_DIO_REPORT_EVENT | CFG_DIO_REPORT_PERIODIC_MESSAGE );
GpioControl.CfgIo[4]= ( CFG_DIO_TRIGGER_LEVEL | CFG_DIO_REPORT_EVENT | CFG_DIO_REPORT_PERIODIC_MESSAGE );
GpioControl.CfgIo[5]= ( CFG_DIO_TRIGGER_LEVEL | CFG_DIO_REPORT_EVENT | CFG_DIO_REPORT_PERIODIC_MESSAGE );
GpioControl.PeriodSetPoint = PIO_PERIODIC_REPORT;
GpioControl.PeriodCounter = GpioControl.PeriodSetPoint;
GpioTimerId = TMR_SetTimer ( PIO_PERIODIC_TIMERVAL , PROC_PIO, 0x00, FALSE);
return;
}
UINT8 IIC_ReceiveMsg (UINT8 SlaveAddress, UINT8 LenRx)
{
MasterRxFlag = TRUE;
RxCompleteflag = FALSE;
RxPacketpositionptr = &RxPacket[0]; // apuntar al primer elemento de RxPacket
RxBufferfullflag = FALSE;
RxPacketendptr = &RxPacket[(LenRx-1)]; // apuntar a la ubicación del último elemento a recibir
IIC_TransferState = IIC_TRANSFERING; // Estado = Transfiriendo
RxTimerID = TMR_SetTimer ( 500 , PROC_IIC, f_IICTimeout, FALSE);
while(IBSR & IBB){ // mientras el bus IIC esté ocupado
if (IIC_TransferState != IIC_TRANSFERING)
return ERROR;
}
IBCR = (IBEN|IBIE|MSSL|TXRX); // grab bus - start condition initiated
IBDR = (SlaveAddress | 0x01); // address the slave, insruct slave to transmit
while (IIC_TransferState == IIC_TRANSFERING){
REFRESH_WATCHDOG;
}
if ( IIC_TransferState == IIC_RX_OK ){
TMR_FreeTimer (RxTimerID);
return OK;
}
IIC_Init();
return ERROR;
}
///////////////////////////////////////////////////////////////////////////////
// Transiciones para el proceso PROC_PIO
///////////////////////////////////////////////////////////////////////////////
//
//-------------- estado : IDLE ----------------------------------------------------------------
//
//-----------------------------------------------------------------------------
// Lectura periodica de estados de entradas salidas
//-----------------------------------------------------------------------------
//
void f_PioIdleTimeout (void)
{
BYTE bTmpCntr;
BYTE bTmpIdx;
UINT8* pTxBuffer;
UINT8 bTmpToken;
GpioTimerId=0xFF;
GpioControl.PreviousVal = GpioControl.CurrentVal ;
GpioControl.CurrentVal = GIO_GetInpVal();
GpioControl.PeriodCounter--;
bTmpIdx =0x01;
for (bTmpCntr=0 ; bTmpCntr < MAX_DIO_QTTY ; bTmpCntr++)
{
switch ( GpioControl.CfgIo[bTmpCntr] & CFG_DIO_TRIGGER_MASK )
{
case CFG_DIO_TRIGGER_LEVEL:
if ( (GpioControl.PreviousVal & bTmpIdx) != (GpioControl.CurrentVal & bTmpIdx) )
{
if (GpioControl.CurrentVal & bTmpIdx)
{
if (GpioControl.CfgIo[bTmpCntr] & CFG_DIO_REPORT_MESSAGE)
PutEventMsg (EVT_DIO_CHANGEON, PROC_NEXO, PROC_PIO, bTmpCntr);
if (GpioControl.CfgIo[bTmpCntr] & CFG_DIO_REPORT_EVENT)
{
if ( OK == MemGetBuffer ( (void**)(&pTxBuffer), &bTmpToken))
{
(void)sprintf((char *)&(((LOG_EVENT_FORMAT*)pTxBuffer)->Data[0]),"GPIO_NIVEL_ON: %02X \0",
(UINT8)bTmpCntr);
((LOG_EVENT_FORMAT*)pTxBuffer)->EventSource = PROC_PIO;
((LOG_EVENT_FORMAT*)pTxBuffer)->EventLastState = EVENT_STATE_PEND;
((LOG_EVENT_FORMAT*)pTxBuffer)->EventCode = EVENT_CODE_DIO_LEVEL_CHANGE;
((LOG_EVENT_FORMAT*)pTxBuffer)->EventParamByteA = bTmpCntr; // entrada que cambió
((LOG_EVENT_FORMAT*)pTxBuffer)->EventParamByteB = 0x01; // nuevo valor de la entrada
((LOG_EVENT_FORMAT*)pTxBuffer)->EventParamWord = 0x00; // no usado
((LOG_EVENT_FORMAT*)pTxBuffer)->EventParamDword = 0x00; // no usado
PutEventMsg (EVT_LOG_EVENT_SAVE, PROC_DEBUG, PROC_PIO, (UINT16)bTmpToken);
}
}
}
else
{
if (GpioControl.CfgIo[bTmpCntr] & CFG_DIO_REPORT_MESSAGE)
PutEventMsg (EVT_DIO_CHANGEOFF, PROC_NEXO, PROC_PIO, bTmpCntr);
if (GpioControl.CfgIo[bTmpCntr] & CFG_DIO_REPORT_EVENT)
{
if ( OK == MemGetBuffer ( (void**)(&pTxBuffer), &bTmpToken))
{
(void)sprintf((char *)&(((LOG_EVENT_FORMAT*)pTxBuffer)->Data[0]),"GPIO_NIVEL_OFF: %02X \0",
(UINT8)bTmpCntr);
((LOG_EVENT_FORMAT*)pTxBuffer)->EventSource = PROC_PIO;
((LOG_EVENT_FORMAT*)pTxBuffer)->EventLastState = EVENT_STATE_PEND;
((LOG_EVENT_FORMAT*)pTxBuffer)->EventCode = EVENT_CODE_DIO_LEVEL_CHANGE;
((LOG_EVENT_FORMAT*)pTxBuffer)->EventParamByteA = bTmpCntr; // entrada que cambió
((LOG_EVENT_FORMAT*)pTxBuffer)->EventParamByteB = 0x00; // nuevo valor de la entrada
((LOG_EVENT_FORMAT*)pTxBuffer)->EventParamWord = 0x00; // no usado
((LOG_EVENT_FORMAT*)pTxBuffer)->EventParamDword = 0x00; // no usado
PutEventMsg (EVT_LOG_EVENT_SAVE, PROC_DEBUG, PROC_PIO, (UINT16)bTmpToken);
}
}
}
}
break;
case CFG_DIO_TRIGGER_PSLOPE:
if ( (!(GpioControl.PreviousVal & bTmpIdx)) && (GpioControl.CurrentVal & bTmpIdx) )
{
if (GpioControl.CfgIo[bTmpCntr] & CFG_DIO_REPORT_MESSAGE)
PutEventMsg (EVT_DIO_PULSE, PROC_NEXO, PROC_PIO, bTmpCntr);
if (GpioControl.CfgIo[bTmpCntr] & CFG_DIO_REPORT_EVENT)
{
if ( OK == MemGetBuffer ( (void**)(&pTxBuffer), &bTmpToken))
{
(void)sprintf((char *)&(((LOG_EVENT_FORMAT*)pTxBuffer)->Data[0]),"GPIO_PULSO_ON: %02X \0",
(UINT8)bTmpCntr);
((LOG_EVENT_FORMAT*)pTxBuffer)->EventSource = PROC_PIO;
((LOG_EVENT_FORMAT*)pTxBuffer)->EventLastState = EVENT_STATE_PEND;
((LOG_EVENT_FORMAT*)pTxBuffer)->EventCode = EVENT_CODE_DIO_PULSE_ON;
((LOG_EVENT_FORMAT*)pTxBuffer)->EventParamByteA = bTmpCntr; // entrada que cambió
((LOG_EVENT_FORMAT*)pTxBuffer)->EventParamByteB = 0x00; // no usado
((LOG_EVENT_FORMAT*)pTxBuffer)->EventParamWord = 0x00; // no usado
((LOG_EVENT_FORMAT*)pTxBuffer)->EventParamDword = 0x00; // no usado
PutEventMsg (EVT_LOG_EVENT_SAVE, PROC_DEBUG, PROC_PIO, (UINT16)bTmpToken);
}
}
}
break;
default:
break;
}
if ( (!GpioControl.PeriodCounter) && (GpioControl.CfgIo[bTmpCntr] & CFG_DIO_REPORT_PERIODIC_MASK) )
{
if (GpioControl.CfgIo[bTmpCntr] & CFG_DIO_REPORT_PERIODIC_MESSAGE)
PutEventMsg ((GpioControl.CurrentVal & bTmpIdx)?EVT_DIO_STATEON:EVT_DIO_STATEOFF, PROC_NEXO, PROC_PIO, bTmpCntr);
if (GpioControl.CfgIo[bTmpCntr] & CFG_DIO_REPORT_PERIODIC_EVENT)
{
if ( OK == MemGetBuffer ( (void**)(&pTxBuffer), &bTmpToken))
{
(void)sprintf((char *)&(((LOG_EVENT_FORMAT*)pTxBuffer)->Data[0]),"GPIO_NIVEL_#%02X = %02X \0",
(UINT8)bTmpCntr,
(UINT8)(GpioControl.CurrentVal & bTmpIdx)?0x01:0x00 );
((LOG_EVENT_FORMAT*)pTxBuffer)->EventSource = PROC_PIO;
((LOG_EVENT_FORMAT*)pTxBuffer)->EventLastState = EVENT_STATE_PEND;
((LOG_EVENT_FORMAT*)pTxBuffer)->EventCode = EVENT_CODE_DIO_LEVEL_STATE;
((LOG_EVENT_FORMAT*)pTxBuffer)->EventParamByteA = bTmpCntr; // entrada reportada
((LOG_EVENT_FORMAT*)pTxBuffer)->EventParamByteB = (GpioControl.CurrentVal & bTmpIdx)?0x01:0x00;
((LOG_EVENT_FORMAT*)pTxBuffer)->EventParamWord = 0x00; // no usado
((LOG_EVENT_FORMAT*)pTxBuffer)->EventParamDword = 0x00; // no usado
PutEventMsg (EVT_LOG_EVENT_SAVE, PROC_DEBUG, PROC_PIO, (UINT16)bTmpToken);
}
}
}
bTmpIdx *= 2;
}
if (!GpioControl.PeriodCounter)
GpioControl.PeriodCounter = GpioControl.PeriodSetPoint;
GpioTimerId = TMR_SetTimer ( PIO_PERIODIC_TIMERVAL , PROC_PIO, 0x00, FALSE);
return;
}
//-----------------------------------------------------------------------------
// Analizar mensaje de configuracion recibido por canal TCP.
//-----------------------------------------------------------------------------
//
void f_ConfigRxCfgFrame (void)
{
UINT8 TmpWriteByte;
switch (CfgMsgFrame.OpCode){
case CFG_TCP_READ:
CfgMsgInfo.InvCode = SYS_ConfigParam.InvCode;
CfgMsgInfo.ScanRate = SYS_ConfigParam.ScanRate;
CfgMsgInfo.RunConfig = SYS_ConfigParam.RunConfig;
// CfgMsgInfo.SIE_CmdWordA = SIE_ConfigParam.CmdWordA;
eeprom_read_buffer(EE_ADDR_SIE_CMDWA, (UINT8 *)&(CfgMsgInfo.SIE_CmdWordA), 2);
(void)memcpy ((UINT8 *)(&(CfgMsgFrame.Data)),
(UINT8 *)(&CfgMsgInfo),
sizeof(CFG_MSG_INFO));
CfgMsgFrame.Len = sizeof(CFG_MSG_INFO);
break;
case CFG_TCP_READ_CTES:
(void)memcpy ((UINT8 *)(&((CFG_MSG_CTES *)(CfgMsgFrame.Data))->ConsignaFrec),
(UINT8 *)(&(SYS_ConfigParam.ConsignaFrec)),
4*sizeof(float));
eeprom_read_buffer(EE_ADDR_VER_TEXT,
(UINT8 *)(((CFG_MSG_CTES *)(CfgMsgFrame.Data))->UsrText), 30);
CfgMsgFrame.Len = sizeof(CFG_MSG_CTES);
break;
case CFG_TCP_READ_STAT:
IIC_RtcGetDateTime ();
(void)memcpy ((UINT8 *)(&(CfgMsgFrame.Data)),
(UINT8 *)(&StatisticData),
sizeof(STATISTIC_MSG));
CfgMsgFrame.Len = sizeof(STATISTIC_MSG);
break;
case CFG_TCP_READ_VER:
(void)memcpy ((UINT8 *)(&((CFG_MSG_VERSION *)(CfgMsgFrame.Data))->FW_VersionHdr), (UINT8*)(&FwVersionData), sizeof(CFG_FW_VERSION));
eeprom_read_buffer(EE_ADDR_VER_HWVER,
(UINT8 *)(&((CFG_MSG_VERSION *)(CfgMsgFrame.Data))->HW_Version),
SIZE_HW_VER);
eeprom_read_buffer(EE_ADDR_VER_SERIAL,
(UINT8 *)(&((CFG_MSG_VERSION *)(CfgMsgFrame.Data))->Serial),
SIZE_SERIAL);
CfgMsgFrame.Len = sizeof(CFG_MSG_VERSION);
break;
case CFG_TCP_WRITE_VER:
if ( (((CFG_MSG_VERSION *)(CfgMsgFrame.Data))->KeyCode) != VER_KEY_CODE) break;
eeprom_write_buffer(EE_ADDR_VER_HWVER,
(UINT8 *)(&((CFG_MSG_VERSION *)(CfgMsgFrame.Data))->HW_Version),
SIZE_HW_VER);
eeprom_write_buffer(EE_ADDR_VER_SERIAL,
(UINT8 *)(&((CFG_MSG_VERSION *)(CfgMsgFrame.Data))->Serial),
SIZE_SERIAL);
StatisticData.OsStat.MsgRstCntr = 0x00;
StatisticData.OsStat.MsgDogCntr = 0x00;
eeprom_write_buffer(EE_ADDR_DOG_CNTR, (UINT8 *)&(StatisticData.OsStat.MsgDogCntr), 2);
eeprom_write_buffer(EE_ADDR_RST_CNTR, (UINT8 *)&(StatisticData.OsStat.MsgRstCntr), 2);
CfgMsgFrame.Len = 0;
break;
case CFG_TCP_WRITE_CTES:
(void)memcpy ((UINT8 *)(&(SYS_ConfigParam.ConsignaFrec)),
(UINT8 *)(&((CFG_MSG_CTES *)(CfgMsgFrame.Data))->ConsignaFrec),
(4 * sizeof(float)));
eeprom_write_buffer(EE_ADDR_INV_FREC, (UINT8 *)&(SYS_ConfigParam.ConsignaFrec), 4);
eeprom_write_buffer(EE_ADDR_PAR_RELTX, (UINT8 *)&SYS_ConfigParam.RelacionTx, 4);
eeprom_write_buffer(EE_ADDR_PAR_CRESB, (UINT8 *)&SYS_ConfigParam.CoefResbal, 4);
eeprom_write_buffer(EE_ADDR_PAR_RPMOT, (UINT8 *)&SYS_ConfigParam.RpmEnMotor, 4);
eeprom_write_buffer(EE_ADDR_VER_TEXT,
(UINT8 *)(((CFG_MSG_CTES *)(CfgMsgFrame.Data))->UsrText), 30);
CfgMsgFrame.Len = 0;
break;
case CFG_TCP_WRITE_DATE:
(void)memcpy ((UINT8 *)(&(StatisticData.CurrentDateTime.Second)),
(UINT8 *)(&((DATE_TIME *)(CfgMsgFrame.Data))->Second),
(sizeof(DATE_TIME)));
IIC_RtcSetDateTime ();
CfgMsgFrame.Len = 0;
break;
case CFG_TCP_WRITE:
(void)memcpy ((UINT8 *)(&(CfgMsgInfo)),(UINT8 *)(&(CfgMsgFrame.Data)),
(sizeof(CFG_MSG_INFO)));
eeprom_write_buffer(EE_ADDR_INV_TYPE, &(CfgMsgInfo.InvCode), 1);
eeprom_write_buffer(EE_ADDR_IP_ADDR, CfgMsgInfo.TcpIP, 4);
eeprom_write_buffer(EE_ADDR_IP_SUBNET, CfgMsgInfo.TcpMask, 4);
eeprom_write_buffer(EE_ADDR_IP_GATEWAY, CfgMsgInfo.TcpGW, 4);
eeprom_write_buffer(EE_ADDR_MAC, CfgMsgInfo.TcpMAC, 6);
eeprom_write_buffer(EE_ADDR_RUN_CFG, &(CfgMsgInfo.RunConfig), 1);
eeprom_write_buffer(EE_ADDR_TCP_INITOUT, (UINT8 *)&(CfgMsgInfo.var_TCP_INIT_RETRY_TOUT), 2);
eeprom_write_buffer(EE_ADDR_TCP_TOUT, (UINT8 *)&(CfgMsgInfo.var_TCP_DEF_RETRY_TOUT), 2);
eeprom_write_buffer(EE_ADDR_TCP_RETRIES, &(CfgMsgInfo.var_TCP_DEF_RETRIES), 1);
if (!CfgMsgInfo.var_TCP_DEF_RETRIES) CfgMsgInfo.var_TCP_DEF_RETRIES = 7;
if (!CfgMsgInfo.var_TCP_INIT_RETRY_TOUT) CfgMsgInfo.var_TCP_INIT_RETRY_TOUT = 100;
if (!CfgMsgInfo.var_TCP_DEF_RETRY_TOUT) CfgMsgInfo.var_TCP_DEF_RETRY_TOUT = 400;
SYS_ConfigParam.ScanRate = CfgMsgInfo.ScanRate;
SYS_ConfigParam.RunConfig = CfgMsgInfo.RunConfig;
eeprom_write_buffer(EE_ADDR_INV_POLL, (UINT8 *)&(CfgMsgInfo.ScanRate), 2);
eeprom_write_buffer(EE_ADDR_SIE_CMDWA, (UINT8 *)&(CfgMsgInfo.SIE_CmdWordA), 2);
(void)memcpy ((UINT8 *)(&(CfgMsgFrame.Data)),
(UINT8 *)(&CfgMsgInfo),
sizeof(CFG_MSG_INFO));
CfgMsgFrame.Len = sizeof(CFG_MSG_INFO);
break;
case CFG_TCP_GET_IOVALUES:
(void)memcpy ((UINT8 *)(&(CfgMsgFrame.Data[0])),
(UINT8 *)(&(InputOutputData)),
sizeof(GIO_STATE_VAL));
CfgMsgFrame.Len = sizeof(GIO_STATE_VAL);
break;
case CFG_TCP_SET_IOVALUES:
(void)memcpy ( (UINT8 *)(&(InputOutputData)),
(UINT8 *)(&(CfgMsgFrame.Data[0])),
sizeof(GIO_STATE_VAL));
GIO_SetOutVal ( ((GIO_STATE_VAL *)(&(CfgMsgFrame.Data[0])))->DigOutVal );
IIC_DacSetValues();
CfgMsgFrame.Len = sizeof(GIO_STATE_VAL);
break;
case CFG_TCP_RESET:
__asm SEI; // Deshabilitar Interrupciones (RESET)
FOREVER;
break;
case CFG_TCP_POL:
CfgMsgFrame.OpCode = CFG_TCP_ACK;
CfgMsgFrame.Len = 0;
break;
case CFG_TCP_WRITE_FLASH:
FLA_SaveReg (CfgMsgFrame.Parameter, CfgMsgFrame.Len, (UINT8*) &(CfgMsgFrame.Data));
CfgMsgFrame.Len = 0;
break;
case CFG_TCP_READ_FLASH:
FLA_ReadReg (CfgMsgFrame.Parameter, (UINT8)(CfgMsgFrame.AuxParam), (UINT8*) &(CfgMsgFrame.Data));
CfgMsgFrame.Len = (UINT8)(CfgMsgFrame.AuxParam);
break;
case CFG_TCP_UPGRADE_FW:
TmpWriteByte = LDR_UPDATE_LOAD;
eeprom_write_buffer(EE_ADDR_FW_UPDATE, &TmpWriteByte, 1);
__asm SEI; // Deshabilitar Interrupciones (RESET)
FOREVER;
break;
// FW cargado ok, grabar bandera para informar al loader..
case CFG_TCP_VALIDATE_FW:
TmpWriteByte = LDR_UPDATE_VALID;
eeprom_write_buffer(EE_ADDR_FW_UPDATE, &TmpWriteByte, 1);
CfgMsgFrame.Len = 0;
break;
// RECUPERAR EL FW DE FABRICA..
case CFG_TCP_RESTORE_FW:
TmpWriteByte = LDR_FACTORY_TEST;
eeprom_write_buffer(EE_ADDR_FW_UPDATE, &TmpWriteByte, 1);
__asm SEI; // Deshabilitar Interrupciones (RESET)
FOREVER;
break;
default:
CfgMsgFrame.OpCode = CFG_TCP_NAK;
CfgMsgFrame.Len = 0;
break;
}
CfgMsgFrame.RxWindow = CfgMsgFrame.TxWindow;
if (TCP_SendCfgBuff()){ // Error en envio de respuesta
(void)TMR_SetTimer ( TCP_TIMEOUT_SENDRETRY , PROC_CONFIG, 0x00, FALSE); // Reintentar
}
// TCP_SendCfgBuff();
return;
}
interrupt void near SCI0_isr (void)
{
m_SCIB_SCISR1 = SCIB_SCISR1;
//--------------TRANSMISION-------------------------------------------------------
if (( m_SCIB_SCISR1 & SCI1SR1_TC_MASK ) && (SCIB_SCICR2 & SCI1CR2_TCIE_MASK)) // si es interrupcion de TXC
{
if (!SCIB_TxByteCount)
{
SCIB_SCICR2 &= ~(SCI1CR2_SCTIE_MASK); // TIE Interrupt Disable
SCIB_SCICR2 &= ~(SCI1CR2_TE_MASK ); // TE Disable
SCIB_SCICR2 &= ~(SCI1CR2_TCIE_MASK); // TCIE Interrupt Disable
PutEventMsg (EVT_SCI_TXMSG, PROC_SCIB, PROC_SCIB, 0x00);
}
else
{
SCIB_SCIDRL = *SCIB_FrameToTx;
SCIB_FrameToTx++;
SCIB_TxByteCount--;
}
}
//--------------RECEPCION-------------------------------------------------------
//
if ((m_SCIB_SCISR1 & SCI1SR1_RDRF_MASK) && (SCIB_SCICR2 & SCI1CR2_RIE_MASK)){
if (SCIB_RxByteCount) // si quedan bytes por recibir
{
*SCIB_FrameToRx = SCIB_SCIDRL;
m_SCIB_RxMsgLen++;
if ( SCIB_ProtocolFrame == SCI_FRAME_MODBUSRTU ) // Delimitar frame ModbusRTU
{
if ( SCIB_RxByteIdx == 5 )
{
if ( m_SCIB_RxMsg_FC == 16 ) // Write Multiple Registers
{
SCIB_RxByteCount = *SCIB_FrameToRx; // Word count
SCIB_RxByteCount <<= 1; // x2 byte count
SCIB_RxByteCount += 0x03; // CRC + bound effects
SCIB_RxByteIdx = 10; // Para que no entre en los demás if's
}
}
if ( SCIB_RxByteIdx == 2 )
{
if (( m_SCIB_RxMsg_FC == 4)|| // Read Input Register
( m_SCIB_RxMsg_FC == 3)|| // Read Multiple Register
( m_SCIB_RxMsg_FC == 2)|| // Read Input Discrete
( m_SCIB_RxMsg_FC == 100)|| // User defined FC
( m_SCIB_RxMsg_FC == 1)) // Read Coils
{
SCIB_RxByteCount = (UINT16)*SCIB_FrameToRx; // Byte count
SCIB_RxByteCount += 0x03; // CRC + bound effects
SCIB_RxByteIdx = 10; // Para que no entre en los demás if's
}
}
if ( SCIB_RxByteIdx == 1 ) // Segundo Byte: Function Code
{
m_SCIB_RxMsg_FC = *SCIB_FrameToRx;
if (( m_SCIB_RxMsg_FC == 5)|| // Write Coil
( m_SCIB_RxMsg_FC == 6)) // Write Single Register
{
SCIB_RxByteCount = 4; // Bytes restantes de msg. de len fija
SCIB_RxByteCount += 0x03; // CRC + bound effects
SCIB_RxByteIdx = 10; // Para que no entre en los demás if's
}
else if(m_SCIB_RxMsg_FC > 0x80)
{
SCIB_RxByteCount = 1; // Bytes restantes de msg. de len fija
SCIB_RxByteCount += 0x03; // CRC + bound effects
SCIB_RxByteIdx = 10; // Para que no entre en los demás if's
}
}
if ( SCIB_RxByteIdx == 0 )
{
if ( SCIB_RX_TimerID == 0xFF){
// Si no se había incializado un timer de recepción, hacerlo al ingresar el primer byte
SCIB_RX_TimerID = TMR_SetTimer ( SCIB_TMR_RX_TIMEOUT , PROC_SCIB, 0x00, FALSE);
}
}
}
else if ( SCIB_ProtocolFrame == SCI_FRAME_UNITELWAY ) // Delimitar Frame UNITELWAY
{
if ( ( SCIB_RxByteIdx > 3 ) && (SCIB_RxByteCount > 1) )
{
if ( ( *SCIB_FrameToRx == DLE_CHAR) && (SCIB_FrameToRx[m_SCIB_RxMsgLen-2] != DLE_CHAR) )
{
SCIB_RxByteCount++;
}
}
if ( SCIB_RxByteIdx == 3 ) // Cuarto Byte: LEN
{
SCIB_RxByteCount = *SCIB_FrameToRx;
SCIB_RxByteCount++; //
if ( *SCIB_FrameToRx == DLE_CHAR)
{
SCIB_RxByteCount++;
}
}
if ( SCIB_RxByteIdx == 1 ) // Segundo Byte: STX
{
if ( *SCIB_FrameToRx != STX_CHAR)
{
SCIB_SCICR2 &= ~(SCI1CR2_RE_MASK) ; // Rx Disable
SCIB_SCICR2 &= ~(SCI1CR2_RIE_MASK); // Rx Interrupt Disable
PutEventMsg (EVT_SCI_RXMSG, PROC_SCIB, PROC_SCIB, 0x01); // TERMINAR CON ERROR
}
}
if ( SCIB_RxByteIdx == 0 )
{
if ( SCIB_RX_TimerID == 0xFF){
// Si no se había incializado un timer de recepción, hacerlo al ingresar el primer byte
SCIB_RX_TimerID = TMR_SetTimer ( SCIB_TMR_RX_TIMEOUT , PROC_SCIB, 0x00, FALSE);
}
if ( *SCIB_FrameToRx != DLE_CHAR) // Primer Byte debe ser DLE descartar previos
{
SCIB_RxByteCount++;
SCIB_RxByteIdx--;
SCIB_FrameToRx--;
m_SCIB_RxMsgLen--;
}
}
}
else if ( SCIB_ProtocolFrame == SCI_FRAME_SPACOM ) // Delimitar Frame SPACOM
{
*SCIB_FrameToRx &= 0x7F; // SPA es siempre en 7 bits de datos
if ( SCIB_RxByteIdx != 0 )
{
if ( (*SCIB_FrameToRx == 0x0A)&& // cr lf 0x0D 0x0A final del frame
( SCIB_RxByteIdx) )
{
SCIB_RxByteCount = 0x01; // terminar OK
}
}
/*
if ( SCIB_RxByteIdx == 1 ) // Segundo Byte: debe ser '<'
{
if ( *SCIB_FrameToRx != '<') //
{
SCIB_SCICR2 &= ~(SCI1CR2_RE_MASK) ; // Rx Disable
SCIB_SCICR2 &= ~(SCI1CR2_RIE_MASK); // Rx Interrupt Disable
PutEventMsg (EVT_SCI_RXMSG, PROC_SCIB, PROC_SCIB, 0xFF); // ERROR
}
}
*/
if ( SCIB_RxByteIdx == 0 )
{
if ( SCIB_RX_TimerID == 0xFF){
// Si no se había incializado un timer de recepción, hacerlo al ingresar el primer byte
SCIB_RX_TimerID = TMR_SetTimer ( SCIB_TMR_RX_TIMEOUT , PROC_SCIB, 0x00, FALSE);
}
if ( *SCIB_FrameToRx != '<') // Primer Byte debe ser '<' descartar previos
{
SCIB_RxByteCount++;
SCIB_RxByteIdx--;
SCIB_FrameToRx--;
}
}
}
else if ( SCIB_ProtocolFrame == SCI_FRAME_MODBUSRTU_SLV ) // Delimitar frame ModbusRTU Slave
{
if ( SCIB_RxByteIdx == 1 )
{
m_SCIB_RxMsg_FC = *SCIB_FrameToRx;
// TODO: analizar demas peticiones de escrituras, y rechazarlas
if ( m_SCIB_RxMsg_FC <= 6)
{
SCIB_RxByteCount = 0x07; // CRC + 6 data - 1 Rxed
SCIB_RxByteIdx = 10; // Para que no entre en los demás if's
}
else
{
SCIB_RxByteCount = 1; // Bytes restantes de msg. de len fija
SCIB_RxByteIdx = 10; // Para que no entre en los demás if's
SCIB_SCICR2 &= ~(SCI1CR2_RE_MASK) ; // Rx Disable
SCIB_SCICR2 &= ~(SCI1CR2_RIE_MASK); // Rx Interrupt Disable
// TODO: cambiar por evento nuevo RXEND o RXERR
PutEventMsg (EVT_SCI_RXMSG, PROC_SCIB, PROC_SCIB, 0x01);
return;
}
}
if ( SCIB_RxByteIdx == 0 )
{
if ( SCIB_RX_TimerID == 0xFF){
// Si no se había incializado un timer de recepción, hacerlo al ingresar el primer byte
SCIB_RX_TimerID = TMR_SetTimer ( SCIB_TMR_RX_TIMEOUT , PROC_SCIB, 0x00, FALSE);
}
}
}
SCIB_RxByteCount--;
SCIB_RxByteIdx++;
SCIB_FrameToRx++;
if (!SCIB_RxByteCount)
{
SCIB_SCICR2 &= ~(SCI1CR2_RE_MASK) ; // Rx Disable
SCIB_SCICR2 &= ~(SCI1CR2_RIE_MASK); // Rx Interrupt Disable
PutEventMsg (EVT_SCI_RXMSG, PROC_SCIB, PROC_SCIB, 0x00);
}
}
else{
SCIB_TmpVar = SCIB_SCIDRL; // Flush buffer
}
}
//--------------ERROR DE COMUNICACION--------------------------------------------
//
// SCIB_SCICR2 &= ~(SCI1CR2_RE_MASK) ; // Rx Disable
// SCIB_SCICR2 &= ~(SCI1CR2_RIE_MASK); // Rx Interrupt Disable
// SCIB_SCICR2 &= ~(SCI1CR2_TE_MASK ); // Tx Disable
// SCIB_SCICR2 &= ~(SCI1CR2_TCIE_MASK); // TxC Interrupt Disable
// SCIB_ReceiveFrame (3, );
}
//-----------------------------------------------------------------------------
//--RxAtEnd se analiza el mensaje recibido como respuesta a un comando
//
void f_MTSIdleRxMsgEnd (void) {
UINT8 RxEndToken, bTmpIdx, TemperaturaIdx;
void* vpAuxBuffer;
char* MsgValTxt;
float fNivel;
// if ( CurrentMsg.Param && 0xFF00 ) // si hubo error de recepcion...
// Recuperar el puntero al buffer utilizado para recibir el mensaje
// El token del buffer está en la parte baja del parámetro del mensaje
RxEndToken = (UINT8)CurrentMsg.Param;
if (MemGetBufferPtr( RxEndToken , &vpAuxBuffer ) != OK ){
// ABR: control de errores
return;
}
#ifdef UDP_DEBUG_PRINTFON
(void)sprintf((char *)udp_buf,"MTS_MsgRx:%X %s\n",
((BYTE*)vpAuxBuffer)[1], // Comando
((char*)&((BYTE*)vpAuxBuffer)[3])); // Dato_0-0
udp_data_to_send = TRUE;
#endif
if ( MTS_CmdIdx )
{
bTmpIdx = 0x00;
while ( ((BYTE*)vpAuxBuffer)[bTmpIdx] != 0x02) // Buscar bandera de start
{
bTmpIdx++;
if ( bTmpIdx >= MSG_MAX_MTS_LEN )
{
bTmpIdx = 0x00;
break;
}
}
bTmpIdx++;
MsgValTxt = (char*)&(((BYTE*)vpAuxBuffer)[bTmpIdx]);
while ( ((BYTE*)vpAuxBuffer)[bTmpIdx] != ':') // Buscar primer separador de valores
{
bTmpIdx++;
if ( bTmpIdx >= MSG_MAX_MTS_LEN )
{
bTmpIdx = 0x00;
break;
}
}
((BYTE*)vpAuxBuffer)[bTmpIdx] = '\0';
// MsgValTxt = (char*)&(((BYTE*)vpAuxBuffer)[3]);
fNivel = ptrToFloat(MsgValTxt);
if (fNivel)
{
fNivel *= 25.4; // de pulgadas a milimetros
MTS_SensorValues.fResultadoNivelP = fNivel;
}
bTmpIdx++;
MsgValTxt = (char*)&(((BYTE*)vpAuxBuffer)[bTmpIdx]);
while ( ((BYTE*)vpAuxBuffer)[bTmpIdx] != 0x03) // Buscar bandera de fin
{
bTmpIdx++;
if ( bTmpIdx >= MSG_MAX_MTS_LEN )
{
bTmpIdx = 0x00;
break;
}
}
// ((BYTE*)vpAuxBuffer)[16] = '\0'; //15
((BYTE*)vpAuxBuffer)[bTmpIdx] = '\0';
fNivel = ptrToFloat(MsgValTxt);
if (fNivel)
{
fNivel *= 25.4; // de pulgadas a milimetros
MTS_SensorValues.fResultadoNivelI = fNivel;
}
InputOutputData.AAG_Input_A = MTS_SensorValues.fResultadoNivelP;
InputOutputData.AAG_Input_B = MTS_SensorValues.fResultadoNivelI;
// fNivel es h
// fNivel = fResultadoNivelP / (float)100.00;
// fNivel /= RADIO_DIESEL;
fNivel = MTS_SensorValues.fResultadoNivelP / RADIO_DIESEL_100;
fNivel -= 1.00;
MTS_SensorValues.fLitrosTanqueDiesel = ( fNivel * sqrtf(1-powf(fNivel,(float)2)) );
MTS_SensorValues.fLitrosTanqueDiesel += asinf(fNivel);
MTS_SensorValues.fLitrosTanqueDiesel += ((float)2 * _M_PI);
MTS_SensorValues.fLitrosTanqueDiesel -= ((float)1.5 * _M_PI);
MTS_SensorValues.fLitrosTanqueDiesel *= powf(RADIO_DIESEL,(float)2);
MTS_SensorValues.fLitrosTanqueDiesel *= LARGO_DIESEL;
InputOutputData.AAG_Output_A = MTS_SensorValues.fLitrosTanqueDiesel;
fNivel = MTS_SensorValues.fResultadoNivelI / RADIO_DIESEL_100;
fNivel -= 1.00;
MTS_SensorValues.fLitrosTanqueAgua = ( fNivel * sqrtf(1-powf(fNivel,(float)2)) );
MTS_SensorValues.fLitrosTanqueAgua += asinf(fNivel);
MTS_SensorValues.fLitrosTanqueAgua += ((float)2.0 * PI);
MTS_SensorValues.fLitrosTanqueAgua -= ((float)1.5 * PI);
MTS_SensorValues.fLitrosTanqueAgua *= powf(RADIO_DIESEL,(float)2);
MTS_SensorValues.fLitrosTanqueAgua *= LARGO_DIESEL;
InputOutputData.AAG_Output_B = MTS_SensorValues.fLitrosTanqueAgua;
}
else // Es comando de lectura de temperaturas..
{
#if 1
bTmpIdx = 0x00;
while ( ((BYTE*)vpAuxBuffer)[bTmpIdx] != 0x02) // Buscar bandera de start
{
bTmpIdx++;
if ( bTmpIdx >= MSG_MAX_MTS_LEN )
{
bTmpIdx = 0x00;
break;
}
}
bTmpIdx++;
for (TemperaturaIdx=0 ; TemperaturaIdx<5 ; TemperaturaIdx++)
{
MsgValTxt = (char*)&(((BYTE*)vpAuxBuffer)[bTmpIdx]);
while ( ((BYTE*)vpAuxBuffer)[bTmpIdx] != ':') // Buscar separador de valores
{
bTmpIdx++;
if ( bTmpIdx >= MSG_MAX_MTS_LEN )
{
bTmpIdx = 0x00;
break;
}
}
((BYTE*)vpAuxBuffer)[bTmpIdx] = '\0';
MTS_SensorValues.fTemperatura[TemperaturaIdx] = ptrToFloat(MsgValTxt);
MTS_SensorValues.fTemperatura[TemperaturaIdx] -= 32; // de Fareneit a Celcius
MTS_SensorValues.fTemperatura[TemperaturaIdx] *= 5;
MTS_SensorValues.fTemperatura[TemperaturaIdx] /= 9;
bTmpIdx++;
}
MsgValTxt = (char*)&(((BYTE*)vpAuxBuffer)[bTmpIdx]);
while ( ((BYTE*)vpAuxBuffer)[bTmpIdx] != 0x03) // Buscar bandera de fin
{
bTmpIdx++;
if ( bTmpIdx >= MSG_MAX_MTS_LEN )
{
bTmpIdx = 0x00;
break;
}
}
((BYTE*)vpAuxBuffer)[bTmpIdx] = '\0';
MTS_SensorValues.fTemperatura[TemperaturaIdx] = ptrToFloat(MsgValTxt);
MTS_SensorValues.fTemperatura[TemperaturaIdx] -= 32; // de Fareneit a Celcius
MTS_SensorValues.fTemperatura[TemperaturaIdx] *= 5;
MTS_SensorValues.fTemperatura[TemperaturaIdx] /= 9;
#if 0
//#ifdef UDP_DEBUG_PRINTFON
(void)sprintf((char *)udp_buf,"MTS_MsgRx: %#3.1Lf | %#3.1Lf | %#3.1Lf | %#3.1Lf | %#3.1Lf | %#3.1Lf\n",
(double)MTS_SensorValues.fTemperatura[0],
(double)MTS_SensorValues.fTemperatura[1],
(double)MTS_SensorValues.fTemperatura[2],
(double)MTS_SensorValues.fTemperatura[3],
(double)MTS_SensorValues.fTemperatura[4],
(double)MTS_SensorValues.fTemperatura[5]);
udp_data_to_send = TRUE;
#endif
#endif
}
(void)MemFreeBuffer ( RxEndToken); // Liberar el buffer de recepcion
// Iniciar un timer para enviar comando..
MTS_WaitAnswerTimerId = TMR_SetTimer ( TMR_MTS_RESETLINKWAIT , PROC_MTS, 0x00, FALSE);
return;
}
void f_SCIBSendRequest (void)
{
// Si hay transmisión en curso rechazar el requerimiento.
if ( SCIB_TxByteCount ) {
PutEventMsg (SCIB_EVT_SCI_TXERR, SCIB_TargetProc, PROC_SCIB, SCIB_CurrentTxToken);
return;
}
if (SCIB_ConfigByte & CFG_SCI_PHYMODE_MASK){ // modo RS485
RS485_B_RE_ = 1; // TX Mode
RS485_B_DE = 1; // TX Mode
}
LED_GREEN_ON;
// Offset desde donde transmitir, en la parte alta del parámetro
SCIB_TxOffset = (UINT8)((CurrentMsg.Param)>>8);
// El token del buffer está en la parte baja del parámetro del mensaje
SCIB_CurrentTxToken = (UINT8)CurrentMsg.Param;
if ( MemGetBufferPtr( SCIB_CurrentTxToken, (void**) &(SCIB_FrameToTx)) != OK ){
// ABR: control de errores
PutEventMsg (SCIB_EVT_SCI_TXERR, SCIB_TargetProc, PROC_SCIB, SCIB_CurrentTxToken);
return;
}
if ( MemGetUsedLen(SCIB_CurrentTxToken, &SCIB_TxByteCount) != OK) // Bytes a transmitir
MON_ResetIfNotConnected(0x21); // Error de SW, Reset (TODO: revisar acciones a tomar)
if (SCIB_ConfigByte & CFG_SCI_PHYMODE_MASK) // modo RS485
{
SCIB_TX_TimerID = TMR_SetTimer (10, PROC_SCIB, 0x00, FALSE);
FirstEventInCurrentState = (EVENT_FUNCTION*)SCIBProc_TOTRANSMIT; // Esperar establecimiento de TX
}
else
{
SCIB_FrameToTx += SCIB_TxOffset;
#if DEBUG_AT(DBG_LEVEL_4)
if (SYS_ConfigParam.DebugLevel>= DBG_LEVEL_4)
{
(void)sprintf((char *)udp_buf,"SCIB Tx: %d, %d, %d, %d, %d, %d, %d, %d, \n",
SCIB_TxByteCount,
SCIB_FrameToTx[0],
SCIB_FrameToTx[1],
SCIB_FrameToTx[2],
SCIB_FrameToTx[3],
SCIB_FrameToTx[4],
SCIB_FrameToTx[5]);
udp_data_to_send = TRUE;
}
#endif
SCIB_SCIDRL = *SCIB_FrameToTx;
// ABR: 30-NOV-2010 TIP: revisar por qué se comporta distinto bajo algunas condiciones..
// En SPA no se transmite este primer byte ?, entonces se comenta la siguiente linea
SCIB_FrameToTx++;
SCIB_TxByteCount--;
SCIB_SCICR2 |= SCI1CR2_TCIE_MASK; // TxC Interrupt Enable
SCIB_SCICR2 |= SCI1CR2_TE_MASK ; // Tx Enable
//SCIB_SCICR2 |= SCI1CR2_SCTIE_MASK; // Tx Interrupt Enable
}
return;
}
void f_SCIASendRequest (void)
{
// Si hay transmisión en curso rechazar el requerimiento.
if ( SCIA_TxByteCount ) {
PutEventMsg (EVT_SCI_TXERR, SCIA_TargetProc, PROC_SCIA, SCIA_CurrentTxToken);
return;
}
if (SCIA_ConfigByte & CFG_SCI_PHYMODE_MASK){ // modo RS485
RS485_A_RE_ = 1; // TX Mode
RS485_A_DE = 1; // TX Mode
}
LED_GREEN_ON;
// Offset desde donde transmitir, en la parte alta del parámetro
SCIA_TxOffset = (UINT8)((CurrentMsg.Param)>>8);
// El token del buffer está en la parte baja del parámetro del mensaje
SCIA_CurrentTxToken = (UINT8)CurrentMsg.Param;
if ( MemGetBufferPtr( SCIA_CurrentTxToken, (void**) &(SCIA_FrameToTx)) != OK ){
// ABR: control de errores
#if DEBUG_AT(DBG_LEVEL_2)
if (SYS_ConfigParam.DebugLevel>= DBG_LEVEL_2)
{
(void)sprintf((char *)udp_buf,"SCIA Err:0x0A \n");
udp_data_to_send = TRUE;
}
#endif
PutEventMsg (EVT_SCI_TXERR, SCIA_TargetProc, PROC_SCIA, SCIA_CurrentTxToken);
return;
}
if ( MemGetUsedLen(SCIA_CurrentTxToken, &SCIA_TxByteCount) != OK) // Bytes a transmitir
{
//MON_ResetIfNotConnected(0x11); // Error de SW, Reset (TODO: revisar acciones a tomar)
#if DEBUG_AT(DBG_LEVEL_2)
if (SYS_ConfigParam.DebugLevel>= DBG_LEVEL_2)
{
(void)sprintf((char *)udp_buf,"SCIA Err:0x0B \n");
udp_data_to_send = TRUE;
}
#endif
PutEventMsg (EVT_SCI_TXERR, SCIA_TargetProc, PROC_SCIA, SCIA_CurrentTxToken);
return;
}
if (SCIA_ConfigByte & CFG_SCI_PHYMODE_MASK) // modo RS485
{
// ABR_2012-03-22: Revisar valor de timer de espera para transmitir, parametrizarlo dinamicamente
SCIA_TX_TimerID = TMR_SetTimer (SCIA_TMR_DRIVE_TIMEOUT, PROC_SCIA, 0x00, FALSE);
FirstEventInCurrentState = (EVENT_FUNCTION*)SCIAProc_TOTRANSMIT; // Esperar establecimiento de TX
}
else
{
SCIA_TmpVar = SCIA_SCIDRL; // Flush buffer
SCIA_TmpVar = SCIA_SCISR1; // Clear pending flag
SCIA_FrameToTx += SCIA_TxOffset;
SCIA_SCIDRL = *SCIA_FrameToTx;
// ABR: 30-NOV-2010 TIP: revisar por qué se comporta distinto bajo algunas condiciones..
// En SPA no se transmite este primer byte ?, entonces se comenta la siguiente linea
SCIA_FrameToTx++;
SCIA_TxByteCount--;
SCIA_SCICR2 |= SCI1CR2_TCIE_MASK; // TxC Interrupt Enable
SCIA_SCICR2 |= SCI1CR2_TE_MASK ; // Tx Enable
// SCIA_SCICR2 |= SCI1CR2_SCTIE_MASK; // Tx Interrupt Enable
}
return;
}
interrupt void near SCI1_isr (void)
{
m_SCIA_SCISR1 = SCIA_SCISR1;
//--------------RECEPCION-------------------------------------------------------
//
if ((m_SCIA_SCISR1 & SCI1SR1_RDRF_MASK) && (SCIA_SCICR2 & SCI1CR2_RIE_MASK)){
if (SCIA_RxByteCount) // si quedan bytes por recibir
{
*SCIA_FrameToRx = SCIA_SCIDRL;
m_RxMsgLen++;
if ( SCIA_ProtocolFrame == SCI_FRAME_MODBUSRTU ) // Delimitar frame ModbusRTU
{
if ( SCIA_RxByteIdx == 5 )
{
if ( m_RxMsg_FC == 16 ) // Write Multiple Registers
{
SCIA_RxByteCount = *SCIA_FrameToRx; // Byte count
//SCIA_RxByteCount <<= 1; // x2 byte count
SCIA_RxByteCount += 0x03; // CRC + bound effects
SCIA_RxByteIdx = 10; // Para que no entre en los demás if's
}
}
if ( SCIA_RxByteIdx == 2 )
{
if (( m_RxMsg_FC == 4)|| // Read Input Register
( m_RxMsg_FC == 3)|| // Read Multiple Register
( m_RxMsg_FC == 2)|| // Read Input Discrete
( m_RxMsg_FC == 100)|| // User defined FC
( m_RxMsg_FC == 1)) // Read Coils
{
SCIA_RxByteCount = (UINT16)*SCIA_FrameToRx; // Byte count
SCIA_RxByteCount += 0x03; // CRC + bound effects
SCIA_RxByteIdx = 10; // Para que no entre en los demás if's
}
}
if ( SCIA_RxByteIdx == 1 ) // Segundo Byte: Function Code
{
m_RxMsg_FC = *SCIA_FrameToRx;
if (( m_RxMsg_FC == 5)|| // Write Coil
( m_RxMsg_FC == 6)|| // Write Single Register
( m_RxMsg_FC == 16)) // Write Multiple Register
{
SCIA_RxByteCount = 4; // Bytes restantes de msg. de len fija
SCIA_RxByteCount += 0x03; // CRC + bound effects
SCIA_RxByteIdx = 10; // Para que no entre en los demás if's
}
else if(m_RxMsg_FC > 0x80)
{
SCIA_RxByteCount = 1; // Bytes restantes de msg. de len fija
SCIA_RxByteCount += 0x03; // CRC + bound effects
SCIA_RxByteIdx = 10; // Para que no entre en los demás if's
}
}
if ( SCIA_RxByteIdx == 0 )
{
if ( SCIA_RX_TimerID == 0xFF){
// Si no se había incializado un timer de recepción, hacerlo al ingresar el primer byte
SCIA_RX_TimerID = TMR_SetTimer ( SCIA_TMR_RX_TIMEOUT , PROC_SCIA, 0x00, FALSE);
}
}
}
else if ( SCIA_ProtocolFrame == SCI_FRAME_SPACOM ) // Delimitar Frame SPACOM
{
*SCIA_FrameToRx &= 0x7F; // SPA es siempre en 7 bits de datos
if ( SCIA_RxByteIdx != 0 )
{
if ( (*SCIA_FrameToRx == 0x0A)&& // cr lf 0x0D 0x0A final del frame
( SCIA_RxByteIdx) )
{
SCIA_RxByteCount = 0x01; // terminar OK
}
}
/*
if ( SCIA_RxByteIdx == 1 ) // Segundo Byte: debe ser '<'
{
if ( *SCIA_FrameToRx != '<') //
{
SCIA_SCICR2 &= ~(SCI1CR2_RE_MASK) ; // Rx Disable
SCIA_SCICR2 &= ~(SCI1CR2_RIE_MASK); // Rx Interrupt Disable
PutEventMsg (EVT_SCI_RXMSG, PROC_SCIA, PROC_SCIA, 0xFF); // ERROR
}
}
*/
if ( SCIA_RxByteIdx == 0 )
{
if ( SCIA_RX_TimerID == 0xFF){
// Si no se había incializado un timer de recepción, hacerlo al ingresar el primer byte
SCIA_RX_TimerID = TMR_SetTimer ( SCIA_TMR_RX_TIMEOUT , PROC_SCIA, 0x00, FALSE);
}
if ( *SCIA_FrameToRx != '<') // Primer Byte debe ser '<' descartar previos
{
SCIA_RxByteCount++;
SCIA_RxByteIdx--;
SCIA_FrameToRx--;
}
}
}
else if ( SCIA_ProtocolFrame == SCI_FRAME_MODBUSRTU_SLV ) // Delimitar frame ModbusRTU Slave
{
if ( SCIA_RxByteIdx == 1 )
{
m_RxMsg_FC = *SCIA_FrameToRx;
// TODO: analizar demas peticiones de escrituras, y rechazarlas
if (( m_RxMsg_FC == 5)|| // Write Coil
( m_RxMsg_FC == 6)) // Write Single Register
{
SCIA_RxByteCount = 1; // Bytes restantes de msg. de len fija
SCIA_RxByteIdx = 10; // Para que no entre en los demás if's
SCIA_SCICR2 &= ~(SCI1CR2_RE_MASK) ; // Rx Disable
SCIA_SCICR2 &= ~(SCI1CR2_RIE_MASK); // Rx Interrupt Disable
// TODO: cambiar por evento nuevo RXEND o RXERR
PutEventMsg (EVT_SCI_RXMSG, PROC_SCIA, PROC_SCIA, 0x01);
return;
}
else
{
SCIA_RxByteCount = 0x09; // CRC + bound effects + 6 data
SCIA_RxByteIdx = 10; // Para que no entre en los demás if's
}
}
if ( SCIA_RxByteIdx == 0 )
{
if ( SCIA_RX_TimerID == 0xFF){
// Si no se había incializado un timer de recepción, hacerlo al ingresar el primer byte
SCIA_RX_TimerID = TMR_SetTimer ( SCIA_TMR_RX_TIMEOUT , PROC_SCIA, 0x00, FALSE);
}
}
}
else if ( SCIA_ProtocolFrame == SCI_FRAME_BIOMETRIC_ANVIZ ) // Delimitar frame Anviz lector Biometrico
{
if ( SCIA_RxByteIdx == 5 )
{
m_RxMsg_FC = *SCIA_FrameToRx;
if ( m_RxMsg_FC == 0xBC ) // Respuesta a primera consulta general ( 29 Bytes )
{
SCIA_RxByteCount = 24; // bound effects + 23 data
SCIA_RxByteIdx = 10; // Para que no entre en los demás if's
}
else if( m_RxMsg_FC == 0xC0 ) // Respuesta a segunda consulta si hay regs. ( 26 Bytes )
{
SCIA_RxByteCount = 21; // bound effects + 20 data
SCIA_RxByteIdx = 10; // Para que no entre en los demás if's
}
else if( m_RxMsg_FC == 0xCE ) // Respuesta a tercera consulta si hay regs. ( 14 Bytes )
{
SCIA_RxByteCount = 9; // bound effects + 8 data
SCIA_RxByteIdx = 10; // Para que no entre en los demás if's
}
else
{
SCIA_SCICR2 &= ~(SCI1CR2_RE_MASK) ; // Rx Disable
SCIA_SCICR2 &= ~(SCI1CR2_RIE_MASK); // Rx Interrupt Disable
// TODO: cambiar por evento nuevo RXEND o RXERR
PutEventMsg (EVT_SCI_RXMSG, PROC_SCIA, PROC_SCIA, 0x01);
return;
}
}
if ( SCIA_RxByteIdx == 0 )
{
if ( SCIA_RX_TimerID == 0xFF){
// Si no se había incializado un timer de recepción, hacerlo al ingresar el primer byte
SCIA_RX_TimerID = TMR_SetTimer ( SCIA_TMR_RX_TIMEOUT , PROC_SCIA, 0x00, FALSE);
}
}
}
SCIA_RxByteCount--;
SCIA_RxByteIdx++;
SCIA_FrameToRx++;
if (!SCIA_RxByteCount)
{
SCIA_SCICR2 &= ~(SCI1CR2_RE_MASK) ; // Rx Disable
SCIA_SCICR2 &= ~(SCI1CR2_RIE_MASK); // Rx Interrupt Disable
PutEventMsg (EVT_SCI_RXMSG, PROC_SCIA, PROC_SCIA, 0x00);
}
}
else{
SCIA_TmpVar = SCIA_SCIDRL; // Flush buffer
}
}
//--------------TRANSMISION-------------------------------------------------------
if (( m_SCIA_SCISR1 & SCI1SR1_TC_MASK ) && (SCIA_SCICR2 & SCI1CR2_TCIE_MASK)) // si es interrupcion de TXC
{
if (!SCIA_TxByteCount)
{
SCIA_SCICR2 &= ~(SCI1CR2_SCTIE_MASK); // TIE Interrupt Disable
SCIA_SCICR2 &= ~(SCI1CR2_TE_MASK ); // TE Disable
SCIA_SCICR2 &= ~(SCI1CR2_TCIE_MASK); // TCIE Interrupt Disable
PutEventMsg (EVT_SCI_TXMSG, PROC_SCIA, PROC_SCIA, 0x00);
}
else
{
SCIA_SCIDRL = *SCIA_FrameToTx;
SCIA_FrameToTx++;
SCIA_TxByteCount--;
}
}
//--------------ERROR DE COMUNICACION--------------------------------------------
//
// SCIA_SCICR2 &= ~(SCI1CR2_RE_MASK) ; // Rx Disable
// SCIA_SCICR2 &= ~(SCI1CR2_RIE_MASK); // Rx Interrupt Disable
// SCIA_SCICR2 &= ~(SCI1CR2_TE_MASK ); // Tx Disable
// SCIA_SCICR2 &= ~(SCI1CR2_TCIE_MASK); // TxC Interrupt Disable
// SCIA_ReceiveFrame (3, );
}
