static bool cbPollCreg ( adl_atResponse_t *Rsp ) {
ascii *rsp;
ascii regStateString [ 3 ];
s32 regStateInt;
TRACE ( ( NORMAL_TRACE_LEVEL, "(cbPollCreg) Enter." ) ) ;
rsp = ( ascii * ) adl_memGet ( Rsp->StrLength );
wm_strRemoveCRLF ( rsp, Rsp->StrData, Rsp->StrLength );
TRACE ( ( NORMAL_TRACE_LEVEL, rsp ) ) ;
wm_strGetParameterString ( regStateString, Rsp->StrData, 2 );
regStateInt = wm_atoi ( regStateString );
TRACE ( ( NORMAL_TRACE_LEVEL, regStateString ) ) ;
if ( REG_STATE_REG == regStateInt || REG_STATE_ROAM == regStateInt ) {
TRACE( ( NORMAL_TRACE_LEVEL, "(cbPollCreg) Registered on GPRS network." ) ) ;
/* Registration is complete so open and start bearer */
OpenAndStartBearer ( ) ;
}
else {
/* Not ready yet, we'll check again later. Set a one-off timer. */
adl_tmrSubscribe ( FALSE, CREG_POLLING_PERIOD, ADL_TMR_TYPE_100MS, (adl_tmrHandler_t ) PollCreg );
}
adl_memRelease(rsp);
return FALSE;
}
/*
* Gibt eine Information auf der externen Applikation aus
*/
void info(ascii * Message)
{
// Benötigter Speicher für die Formatierungen
const static u8 overhead = 12;
// Speicher für die Ausgabe der Nachricht
ascii * buffer =
(ascii *) adl_memGet(
wm_strlen(Message)
+ overhead
);
// Formatierung der Nachricht für die Ausgabe
wm_sprintf(
buffer,
"\r\n+INFO: %s\r\n",
Message
);
// Ausgabe der Nachricht
adl_atSendUnsoResponse(
ADL_PORT_UART1,
buffer,
FALSE
);
// Freigabe des Speichers
adl_memRelease(buffer);
}
/* The I2C device function called for accessing the Device */
int ioCallToI2CDevice( char *i_DeviceAddr, char *i_Cmd, char *i_Reg,char *i_Data, u8* rxData)
{
s32 sReturn = 0;
u8 DeviceAddr = 0x0;
unsigned int iterator=0;
int Length = 0;
u8 ReadWriteFlag = 0;
unsigned int ReadCnt = 0;
u8 *Data;
//u8 Data[2049];
u8 ShortDeviceReg = 0;
u16 LongDeviceReg = 0;
u32 DeviceRegSize =0;
u32 writeLength = 0;
int retVal= 0;
char Str[1024];
int msgcnt = 0;
do
{
Length = strlen(i_DeviceAddr );
if( Length != 7 )
{
TRACE((I2C_TRACE_LEVEL,"Device Address must be specified as 7 bits in length"));
TRACE((I2C_TRACE_LEVEL,"%d",i_DeviceAddr));
retVal = -1;
break;
}
if( *i_Cmd == 'r' || *i_Cmd == 'R' )
{
TRACE((I2C_TRACE_LEVEL,"we're doing a Read operation\n"));
ReadWriteFlag = 1; // set flag to one for read
}
for(iterator=0; iterator<7; iterator++)
{
DeviceAddr = DeviceAddr<<1;
// shift address up one bit
if( *(i_DeviceAddr + iterator) == '1')
DeviceAddr |= 0x1;
}
TRACE((I2C_TRACE_LEVEL,"Device Address is: %d",DeviceAddr));
Length = strlen( i_Reg );
TRACE((I2C_TRACE_LEVEL,"register address size: %d\n",Length));
if( Length == 2 )
{
DeviceRegSize = 8;
ShortDeviceReg = CmdToU8(*i_Reg) << 4;
ShortDeviceReg |= CmdToU8(*(i_Reg+1));
TRACE((I2C_TRACE_LEVEL,"short Device Reg: %d",ShortDeviceReg));
}
else
{
DeviceRegSize = 16;
LongDeviceReg = (u16)(CmdToU8( *i_Reg ) << 12);
LongDeviceReg |= (u16)(CmdToU8( *(i_Reg+1) ) << 8);
LongDeviceReg |= (u16)(CmdToU8( *(i_Reg+2) ) << 4);
LongDeviceReg |= (u16)(CmdToU8( *(i_Reg+3) ));
TRACE((I2C_TRACE_LEVEL,"long Device Reg: %d",LongDeviceReg));
}
if( ReadWriteFlag )
{
sReturn = i2c_Subscribe( DeviceAddr );
if( sReturn < 0 )
{
retVal=-1;
break;
}
ReadCnt = atoi(i_Data);
TRACE((I2C_TRACE_LEVEL,"read %d bytes from device",ReadCnt));
//Data = (u8 *)malloc(ReadCnt);
Data = (u8 *)adl_memGet(ReadCnt);
if( DeviceRegSize == 8 )
AccessConfig.Address=(ShortDeviceReg << 24);
else
AccessConfig.Address=(LongDeviceReg << 16);
sReturn = adl_busIOCtl( i2cHandle, ADL_BUS_CMD_SET_ADD_SIZE,&DeviceRegSize );
if(sReturn < 0)
{
//DisplayErrorCode("adl_busIOCtl",__FILE__,__LINE__,sReturn);
retVal = -1;
break;
}
gI2CSignalFlag = 1;
sReturn = adl_busRead(i2cHandle,&AccessConfig,ReadCnt,Data);
if( sReturn < 0 )
{
gI2CSignalFlag = 0;
TRACE((I2C_TRACE_LEVEL,"ERROR in busRead: %d"));
retVal = -1;
break;
}
//FIXME: Changed this code for the test (Could present future watchdog issue if the wavecom fails for some reason)
// sReturn = adl_semConsumeDelay( gI2CSemHndl,60);
#ifdef REMOVE_SEM
sReturn = adl_semConsume(gI2CSemHndl);
if( sReturn < 0 )
{
if( sReturn == -8 )
{
// timeout happened, produce and continue
TRACE((I2C_TRACE_LEVEL,"semConsumeDelay happened"));
if( adl_semIsConsumed( gI2CSemHndl ) == TRUE )
{
sReturn = adl_semProduce( gI2CSemHndl );
if( sReturn < 0 );
//DisplayErrorCode("adl_semProduce",__FILE__,__LINE__,sReturn);
}
}
else
//DisplayErrorCode("adl_semConsumeDelay",__FILE__,__LINE__,sReturn);
return -1;
}
#else
//gI2CSignalFlag = 1;
while(gI2CSignalFlag )
adl_ctxSleep(1);
#endif
msgcnt = 0;
for (iterator=0; iterator<ReadCnt; iterator++)
{
//printf("%x ",*(Data+x));
if( (Data[iterator] > 0x1f) && (Data[iterator] < 0x7b) )
{
if(msgcnt < 1020 )
Str[msgcnt++] = Data[iterator];
}
else
{
if(msgcnt > 5 )
{
Str[msgcnt++] = 0xA;
Str[msgcnt++] = 0xd;
Str[msgcnt] = 0x0;
TRACE((I2C_TRACE_LEVEL,"%s",Str));
}
msgcnt = 0;
}
}
if(msgcnt > 5 )
{
Str[msgcnt++] = 0xA;
Str[msgcnt++] = 0xd;
Str[msgcnt] = 0x0;
TRACE((I2C_TRACE_LEVEL,"%s",Str));
msgcnt = 0;
}
if(rxData != NULL)
memcpy(rxData,Data,ReadCnt);
//printf("\n");
// free(Data);
// Data = NULL;
adl_memRelease(Data);
Data = NULL;
}
else
{
sReturn = i2c_Subscribe( DeviceAddr );
if( sReturn < 0 )
{
retVal = -1;
break;
}
if( DeviceRegSize == 8 )
AccessConfig.Address=(ShortDeviceReg << 24);
else
AccessConfig.Address=(LongDeviceReg << 16);
sReturn = adl_busIOCtl( i2cHandle, ADL_BUS_CMD_SET_ADD_SIZE,&DeviceRegSize );
if(sReturn < 0)
{
//DisplayErrorCode("adl_busIOCtl",__FILE__,__LINE__,sReturn);
retVal = -1;
break;
}
ReadCnt =strlen(i_Data);
//Data = (u8 *)malloc(ReadCnt);
Data = (u8 *)adl_memGet(ReadCnt);
// AB: CRITICAL. I agree. Behavior of x may be undefined. Rewrote.
//TVDP: CRITICAL Daring use of pointer step (x)
if (Data == NULL)
{
break;
}
writeLength = 0;
iterator = 0;
while ( iterator < ReadCnt )
{
Data[writeLength] = CmdToU8( i_Data[iterator++] )<<4 ;
Data[writeLength++] |= CmdToU8( i_Data[iterator++]);
}
TRACE((I2C_TRACE_LEVEL,"data to write"));
for(iterator=0; iterator<writeLength; iterator++)
{
TRACE((I2C_TRACE_LEVEL,"%d",Data[iterator]));
}
sReturn = adl_busWrite(i2cHandle,&AccessConfig,writeLength,(void *)Data);
if( sReturn < 0 )
{
TRACE((I2C_TRACE_LEVEL,"ERROR in adl_busWrite: %d\n",sReturn));
retVal = -1;
break;
}
#ifdef REMOVE_SEM
sReturn = adl_semConsume(gI2CSemHndl);
#endif
//free(Data);
//Data = NULL;
adl_memRelease(Data);
Data = NULL;
}
}while(0);
return retVal;
}
void ModbusHandler(SerialContext* pSerialContext, swi_status_t status, void* pUserData) {
u8* pduBuff = NULL;
u16 bufferLength = 0;
int index;
ModbusSpecifics* pSpecifics = SRLFWK_ADP_GetProtocolData(pSerialContext);
ModbusUserData* pModbusData = (ModbusUserData*) pUserData;
if (/*status != SWI_STATUS_SERIAL_RESPONSE_TIMEOUT*/1) {
wm_sprintf(ltsc_Temp, "\r\n >>>>");
adl_atSendResponse(ADL_AT_UNS, ltsc_Temp);
SRLFWK_ADP_GetRequestPDU(pSerialContext, &pduBuff, &bufferLength);
for (index = 0; index < bufferLength; index++) {
wm_sprintf(ltsc_Temp, " %02X ", pduBuff[index]);
adl_atSendResponse(ADL_AT_UNS, ltsc_Temp);
}
bufferLength = 0;
pduBuff = NULL;
wm_sprintf(ltsc_Temp, "\r\n <<<<");
adl_atSendResponse(ADL_AT_UNS, ltsc_Temp);
if (status != SWI_STATUS_SERIAL_RESPONSE_TIMEOUT) {
SRLFWK_ADP_GetResponsePDU(pSerialContext, &pduBuff, &bufferLength);
for (index = 0; index < bufferLength; index++) {
wm_sprintf(ltsc_Temp, " %02X ", pduBuff[index]);
adl_atSendResponse(ADL_AT_UNS, ltsc_Temp);
}
}
}
switch (status) {
case SWI_STATUS_OK:
switch (pSpecifics->response.function) {
case MODBUS_FUNC_READ_COILS:
wm_sprintf(ltsc_Temp, "\r\n <<<< READ COILS");
adl_atSendResponse(ADL_AT_UNS, ltsc_Temp);
wm_sprintf(ltsc_Temp, " ---> OK '%d' coil(s) read on '%d' bytes starting at '%d'", pSpecifics->response.numberOfObjects, pSpecifics->response.byteCount,
pSpecifics->response.startingAddress);
adl_atSendResponse(ADL_AT_UNS, ltsc_Temp);
for (index = 0; index < pSpecifics->response.byteCount; index++) {
wm_sprintf(ltsc_Temp, "\r\n byte '%d' : %02X", index, ((u8*) (pSpecifics->response.value.pValues))[index]);
adl_atSendResponse(ADL_AT_UNS, ltsc_Temp);
}
break;
case MODBUS_FUNC_READ_DISCRETE_INPUTS:
wm_sprintf(ltsc_Temp, "\r\n <<<< READ DISCRETE INPUTS");
adl_atSendResponse(ADL_AT_UNS, ltsc_Temp);
wm_sprintf(ltsc_Temp, " ---> OK '%d' discrete input(s) read on '%d' bytes starting at '%d'", pSpecifics->response.numberOfObjects, pSpecifics->response.byteCount,
pSpecifics->response.startingAddress);
adl_atSendResponse(ADL_AT_UNS, ltsc_Temp);
for (index = 0; index < pSpecifics->response.byteCount; index++) {
wm_sprintf(ltsc_Temp, "\r\n byte '%d' : %02X", index, ((u8*) (pSpecifics->response.value.pValues))[index]);
adl_atSendResponse(ADL_AT_UNS, ltsc_Temp);
}
break;
case MODBUS_FUNC_READ_HOLDING_REGISTERS:
wm_sprintf(ltsc_Temp, "\r\n <<<< READ HOLDING REGISTERS");
adl_atSendResponse(ADL_AT_UNS, ltsc_Temp);
wm_sprintf(ltsc_Temp, " ---> OK '%d' holding register(s) read", pSpecifics->response.numberOfObjects);
adl_atSendResponse(ADL_AT_UNS, ltsc_Temp);
for (index = 0; index < pSpecifics->response.numberOfObjects; index++) {
wm_sprintf(ltsc_Temp, "\r\n value '%d' : %d", index, ((u16*) (pSpecifics->response.value.pValues))[index]);
adl_atSendResponse(ADL_AT_UNS, ltsc_Temp);
}
break;
case MODBUS_FUNC_READ_INPUT_REGISTERS:
wm_sprintf(ltsc_Temp, "\r\n <<<< READ INPUT REGISTERS");
adl_atSendResponse(ADL_AT_UNS, ltsc_Temp);
wm_sprintf(ltsc_Temp, " ---> OK '%d' input register(s) read", pSpecifics->response.numberOfObjects);
adl_atSendResponse(ADL_AT_UNS, ltsc_Temp);
for (index = 0; index < pSpecifics->response.numberOfObjects; index++) {
wm_sprintf(ltsc_Temp, "\r\n value '%d' : %d", index, ((u16*) (pSpecifics->response.value.pValues))[index]);
adl_atSendResponse(ADL_AT_UNS, ltsc_Temp);
}
break;
case MODBUS_FUNC_WRITE_SINGLE_COIL:
wm_sprintf(ltsc_Temp, "\r\n <<<< WRITE COILS");
adl_atSendResponse(ADL_AT_UNS, ltsc_Temp);
wm_sprintf(ltsc_Temp, " ---> OK address: %d - value: %d", pSpecifics->response.startingAddress, (int) pSpecifics->response.value.pValues);
adl_atSendResponse(ADL_AT_UNS, ltsc_Temp);
break;
case MODBUS_FUNC_WRITE_SINGLE_REGISTER:
wm_sprintf(ltsc_Temp, "\r\n <<<< WRITE REGISTER");
adl_atSendResponse(ADL_AT_UNS, ltsc_Temp);
wm_sprintf(ltsc_Temp, " ---> OK address: %d - value: %d", pSpecifics->response.startingAddress, (int) pSpecifics->response.value.pValues);
adl_atSendResponse(ADL_AT_UNS, ltsc_Temp);
break;
case MODBUS_FUNC_WRITE_MULTIPLE_COILS:
wm_sprintf(ltsc_Temp, "\r\n <<<< WRITE MULTIPLE COILS");
adl_atSendResponse(ADL_AT_UNS, ltsc_Temp);
wm_sprintf(ltsc_Temp, " ---> OK address: %d - number: %d", pSpecifics->response.startingAddress, pSpecifics->response.numberOfObjects);
adl_atSendResponse(ADL_AT_UNS, ltsc_Temp);
break;
case MODBUS_FUNC_WRITE_MULTIPLE_REGISTERS:
wm_sprintf(ltsc_Temp, "\r\n <<<< WRITE MULTIPLE REGISTERS");
adl_atSendResponse(ADL_AT_UNS, ltsc_Temp);
wm_sprintf(ltsc_Temp, " ---> OK address: %d - number: %d", pSpecifics->response.startingAddress, pSpecifics->response.numberOfObjects);
adl_atSendResponse(ADL_AT_UNS, ltsc_Temp);
break;
default:
wm_sprintf(ltsc_Temp, "\r\n <<<< UNKNOWN FUNCTION");
adl_atSendResponse(ADL_AT_UNS, ltsc_Temp);
break;
}
break;
case SWI_STATUS_SERIAL_RESPONSE_TIMEOUT:
wm_sprintf(ltsc_Temp, "\r\n <<<< ERROR TIMEOUT");
adl_atSendResponse(ADL_AT_UNS, ltsc_Temp);
break;
case SWI_STATUS_SERIAL_RESPONSE_EXCEPTION:
switch (pSpecifics->response.function) {
case MODBUS_FUNC_READ_COILS:
wm_sprintf(ltsc_Temp, "\r\n <<<< ERROR READ COILS - exception '%02X'", pSpecifics->response.exception);
adl_atSendResponse(ADL_AT_UNS, ltsc_Temp);
break;
case MODBUS_FUNC_READ_DISCRETE_INPUTS:
wm_sprintf(ltsc_Temp, "\r\n <<<< ERROR READ DISCRETE INPUTS - exception '%02X'", pSpecifics->response.exception);
adl_atSendResponse(ADL_AT_UNS, ltsc_Temp);
break;
case MODBUS_FUNC_READ_HOLDING_REGISTERS:
wm_sprintf(ltsc_Temp, "\r\n <<<< ERROR READ HOLDING REGISTERS - exception '%02X'", pSpecifics->response.exception);
adl_atSendResponse(ADL_AT_UNS, ltsc_Temp);
break;
case MODBUS_FUNC_READ_INPUT_REGISTERS:
wm_sprintf(ltsc_Temp, "\r\n <<<< ERROR READ INPUT REGISTERS - exception '%02X'", pSpecifics->response.exception);
adl_atSendResponse(ADL_AT_UNS, ltsc_Temp);
break;
case MODBUS_FUNC_WRITE_SINGLE_COIL:
wm_sprintf(ltsc_Temp, "\r\n <<<< ERROR WRITE COILS - exception '%02X'", pSpecifics->response.exception);
adl_atSendResponse(ADL_AT_UNS, ltsc_Temp);
break;
case MODBUS_FUNC_WRITE_SINGLE_REGISTER:
wm_sprintf(ltsc_Temp, "\r\n <<<< ERROR WRITE REGISTER - exception '%02X'", pSpecifics->response.exception);
adl_atSendResponse(ADL_AT_UNS, ltsc_Temp);
break;
case MODBUS_FUNC_WRITE_MULTIPLE_COILS:
wm_sprintf(ltsc_Temp, "\r\n <<<< ERROR WRITE MULTIPLE COILS - exception '%02X'", pSpecifics->response.exception);
adl_atSendResponse(ADL_AT_UNS, ltsc_Temp);
break;
case MODBUS_FUNC_WRITE_MULTIPLE_REGISTERS:
wm_sprintf(ltsc_Temp, "\r\n <<<< ERROR WRITE MULTIPLE REGISTERS - exception '%02X'", pSpecifics->response.exception);
adl_atSendResponse(ADL_AT_UNS, ltsc_Temp);
break;
default:
wm_sprintf(ltsc_Temp, "\r\n <<<< ERROR UNKNOWN FUNCTION - exception '%02X'", pSpecifics->response.exception);
adl_atSendResponse(ADL_AT_UNS, ltsc_Temp);
break;
}
break;
case SWI_STATUS_SERIAL_RESPONSE_BAD_CHECKSUM:
wm_sprintf(ltsc_Temp, "\r\n <<<< ERROR CHECKSUM BAD");
adl_atSendResponse(ADL_AT_UNS, ltsc_Temp);
break;
default:
case SWI_STATUS_SERIAL_RESPONSE_INVALID_FRAME:
wm_sprintf(ltsc_Temp, "\r\n <<<< ERROR INVALID FRAME");
adl_atSendResponse(ADL_AT_UNS, ltsc_Temp);
break;
}
wm_sprintf(ltsc_Temp, "\r\n ------------------------------------------------------------------------------");
adl_atSendResponse(ADL_AT_UNS, ltsc_Temp);
// free user result buffer
if (pModbusData->allocated != NULL) {
adl_memRelease(pModbusData->allocated);
pModbusData->allocated = NULL;
}
}
void MAIN_PollingTimerHandler(u8 id, void* pContext) {
swi_status_t result = SWI_STATUS_SERIAL_ERROR;
ModbusUserData* pModbusData = (ModbusUserData*) pContext;
pModbusData->request.slaveId = 1;
int index = 0;
u8 value = 0xFF;
wm_sprintf(ltsc_Temp, "\r\n ------------------------------------------------------------------------------");
adl_atSendResponse(ADL_AT_UNS, ltsc_Temp);
switch (choice) {
case 0: // write single coil
pModbusData->request.function = MODBUS_FUNC_WRITE_SINGLE_COIL;
pModbusData->request.startingAddress = 0x0002;
pModbusData->request.value.iValue = (uint32_t) MODBUS_SINGLE_COIL_ON;
wm_sprintf(ltsc_Temp, "\r\n >>>> WRITE SINGLE COIL at '%04X' ON SLAVE '%d'", pModbusData->request.startingAddress, pModbusData->request.slaveId);
adl_atSendResponse(ADL_AT_UNS, ltsc_Temp);
break;
case 1: //read input registers
pModbusData->request.function = MODBUS_FUNC_READ_INPUT_REGISTERS;
pModbusData->request.startingAddress = 0x0000;
pModbusData->request.numberOfObjects = 16;
pModbusData->allocated = adl_memGet(pModbusData->request.numberOfObjects * sizeof(u16));
pModbusData->request.value.pValues = pModbusData->allocated;
wm_sprintf(ltsc_Temp, "\r\n >>>> READ '%d' INPUT REGISTERS starting at '%04X' ON SLAVE '%d'", pModbusData->request.numberOfObjects, pModbusData->request.startingAddress,
pModbusData->request.slaveId);
adl_atSendResponse(ADL_AT_UNS, ltsc_Temp);
break;
case 2: // read coils
pModbusData->request.function = MODBUS_FUNC_READ_COILS;
pModbusData->request.startingAddress = 0x0000;
pModbusData->request.numberOfObjects = 120;
pModbusData->request.byteCount = ((pModbusData->request.numberOfObjects / 8) + (((pModbusData->request.numberOfObjects % 8) != 0) ? 1 : 0));
pModbusData->allocated = adl_memGet(pModbusData->request.byteCount * sizeof(u8));
pModbusData->request.value.pValues = pModbusData->allocated;
wm_sprintf(ltsc_Temp, "\r\n >>>> READ '%d' COILS ('%d' bytes) starting at '%04X' ON SLAVE '%d'", pModbusData->request.numberOfObjects, pModbusData->request.byteCount,
pModbusData->request.startingAddress, pModbusData->request.slaveId);
adl_atSendResponse(ADL_AT_UNS, ltsc_Temp);
break;
case 3: // read holding registers
pModbusData->request.function = MODBUS_FUNC_READ_HOLDING_REGISTERS;
pModbusData->request.startingAddress = 0x0000;
pModbusData->request.numberOfObjects = 10;
pModbusData->allocated = adl_memGet(pModbusData->request.numberOfObjects * sizeof(u16));
pModbusData->request.value.pValues = pModbusData->allocated;
wm_sprintf(ltsc_Temp, "\r\n >>>> READ '%d' HOLDING REGISTERS starting at '%04X' ON SLAVE '%d'", pModbusData->request.numberOfObjects, pModbusData->request.startingAddress,
pModbusData->request.slaveId);
adl_atSendResponse(ADL_AT_UNS, ltsc_Temp);
break;
case 4: // write single register
pModbusData->request.function = MODBUS_FUNC_WRITE_SINGLE_REGISTER;
pModbusData->request.startingAddress = 0x0000;
pModbusData->request.value.iValue = (uint32_t) 1;
wm_sprintf(ltsc_Temp, "\r\n >>>> WRITE SINGLE REGISTER at '%04X' ON SLAVE '%d'", pModbusData->request.startingAddress, pModbusData->request.slaveId);
adl_atSendResponse(ADL_AT_UNS, ltsc_Temp);
break;
case 5: // write multiple coils
pModbusData->request.function = MODBUS_FUNC_WRITE_MULTIPLE_COILS;
pModbusData->request.startingAddress = 0x0000;
pModbusData->request.numberOfObjects = 120;
pModbusData->request.byteCount = ((pModbusData->request.numberOfObjects / 8) + (((pModbusData->request.numberOfObjects % 8) != 0) ? 1 : 0));
pModbusData->allocated = adl_memGet(pModbusData->request.byteCount * sizeof(u8));
pModbusData->request.value.pValues = pModbusData->allocated;
for (index = 0; index < pModbusData->request.byteCount; index++) {
value = value ^ 0xFF;
((u8*) pModbusData->request.value.pValues)[index] = value;
}
wm_sprintf(ltsc_Temp, "\r\n >>>> WRITE '%d' COILS starting at '%04X' ON SLAVE '%d'", pModbusData->request.numberOfObjects, pModbusData->request.startingAddress, pModbusData->request.slaveId);
adl_atSendResponse(ADL_AT_UNS, ltsc_Temp);
break;
case 6: // write multiple registers
pModbusData->request.function = MODBUS_FUNC_WRITE_MULTIPLE_REGISTERS;
pModbusData->request.startingAddress = 0x0000;
pModbusData->request.numberOfObjects = 120;
pModbusData->allocated = adl_memGet(pModbusData->request.numberOfObjects * sizeof(u16));
pModbusData->request.value.pValues = pModbusData->allocated;
for (index = 0; index < pModbusData->request.numberOfObjects; index++) {
((u16*) pModbusData->request.value.pValues)[index] = 2 * index + 1;
}
wm_sprintf(ltsc_Temp, "\r\n >>>> WRITE MULTIPLE '%d' REGISTERS starting at '%04X' ON SLAVE '%d'", pModbusData->request.numberOfObjects, pModbusData->request.startingAddress,
pModbusData->request.slaveId);
adl_atSendResponse(ADL_AT_UNS, ltsc_Temp);
break;
case 7: // read discrete input
pModbusData->request.function = MODBUS_FUNC_READ_DISCRETE_INPUTS;
pModbusData->request.startingAddress = 0x0000;
pModbusData->request.numberOfObjects = 120;
pModbusData->request.byteCount = ((pModbusData->request.numberOfObjects / 8) + (((pModbusData->request.numberOfObjects % 8) != 0) ? 1 : 0));
pModbusData->allocated = adl_memGet(pModbusData->request.byteCount * sizeof(u8));
pModbusData->request.value.pValues = pModbusData->allocated;
wm_sprintf(ltsc_Temp, "\r\n >>>> READ '%d' DISCRETE INPUTS ('%d' bytes) starting at '%04X' ON SLAVE '%d'", pModbusData->request.numberOfObjects, pModbusData->request.byteCount,
pModbusData->request.startingAddress, pModbusData->request.slaveId);
adl_atSendResponse(ADL_AT_UNS, ltsc_Temp);
break;
default:
wm_sprintf(ltsc_Temp, "\r\n >>>> ???");
adl_atSendResponse(ADL_AT_UNS, ltsc_Temp);
return;
}
result = SRLFWK_ADP_Request(pModbusData->pSerialContext, &pModbusData->request);
if (result == SWI_STATUS_OK) {
// print pModbusData->request
wm_sprintf(ltsc_Temp, "\r\n >>>> polling DONE '%d'", result);
adl_atSendResponse(ADL_AT_UNS, ltsc_Temp);
} else {
if (pModbusData->allocated != NULL) {
adl_memRelease(pModbusData->allocated);
pModbusData->allocated = NULL;
}
wm_sprintf(ltsc_Temp, "\r\n >>>> ERROR polling '%d'", result);
adl_atSendResponse(ADL_AT_UNS, ltsc_Temp);
wm_sprintf(ltsc_Temp, "\r\n ------------------------------------------------------------------------------");
adl_atSendResponse(ADL_AT_UNS, ltsc_Temp);
}
choice = (choice + 1) % 8;
}
