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; }