/**
* FMB_Poll_Task
*
* @param none
* @return none
*
* @brief FMB_Poll_Task
*/
void FMB_Poll_Task(void *arg)
{
printf("RS485_Init ERRORCode = %d\n",eMBMasterInit(MB_RTU,RS485_1,1200,MB_PAR_ODD));
printf("RS485_Enable ERRORCode = %d\n",eMBMasterEnable());
while(1)
{
printf("RS485_Poll ERRORCode = %d\n",eMBMasterPoll());
OSTimeDly(500);
}
}
int main( int argc, char *argv[] )
{
int c;
int option_index = 0;
int received;
int mq_id;
struct sIPCMsg mymsg;
char *ttydev = DEFAULT_TTY;
char *parity_s = DEFAULT_PAR;
int parity;
int baud = DEFAULT_BAUD;
USHORT result[255] = {0,};
int result_int = 0;
USHORT usLen;
eMBErrorCode err = MB_ENOERR;
int reg_start = DEFAULT_REGISTER_START;
int address = DEFAULT_ADDRESS;
int regt = -1;
int reg_action = -1;
int reg_action_param = -1;
int no_reg = -1;
int run_forground = 0;
int errorcount = 0;
struct pidfile *pidfile = NULL;
UCHAR *pucFrame;
eMBException eException;
UCHAR ucFuncType;
/* Parse cmd-line options */
while ( (c = getopt_long (argc, argv, "hVd:s:p:r:t:c:a:f", long_options, &option_index)) != EOF ) {
switch (c) {
case 'h':
fprintf(stderr, "%s", helptext);
exit(EXIT_SUCCESS);
case 'V':
exit(EXIT_SUCCESS);
case 'd':
ttydev = strndup(optarg, MAXLEN);
break;
case 's':
baud = atoi(optarg);
break;
case 'p':
parity_s = strndup(optarg, MAXLEN);
break;
case 'f': // run in forground
run_forground = 1;
break;
case '?':
/* getopt_long already printed an error message. */
default:
fprintf(stderr, "%s", helptext);
exit(EXIT_SUCCESS);
}
}
if(!run_forground){
fprintf(stderr, "Deamonizing...\n");
daemon(0, 0);
}
/* Setup signalhandler so that we shut down
nicely on CTRL+C */
signal(SIGINT, int_handler);
pidfile = pidfile_create(DEFAULT_PIDFILE, PMODE_RETURN, 0);
mq_id = create_ipc();
/* Allocate space for an ADU frame */
pucFrame = eMBAllocateFrame(&usLen);
while(outer_loop) {
if(running == 1)
printf("Restarting modbus layer\n");
else {
printf("\n\n\n\n Restarting modbus layer\n\n\n\n");
running = 1;
errorcount = 0;
}
/* Parse user inputs... */
if(strcmp(parity_s, "even") == 0)
parity = MB_PAR_EVEN;
else if(strcmp(parity_s, "odd") == 0)
parity = MB_PAR_ODD;
else
parity = MB_PAR_NONE;
PRINT_DBG(1, "init modbus at tty: %s parity %d baud %d", ttydev, parity, baud);
/* mode, port, baud, parity */
eMBMasterInit(MB_RTU, ttydev, baud, parity);
while(running) {
/* Check message queue */
if((received = msgrcv(mq_id, &mymsg, sizeof(mymsg.text), 1, IPC_NOWAIT)) > 0) {
/* Address */
address = parse_address(mymsg.text);
/* Starting register */
reg_start = parse_reg_start(mymsg.text);
/* Register type */
regt = parse_reg_type(mymsg.text);
/* Register action */
reg_action_param = 0;
reg_action = parse_reg_action(mymsg.text, ®_action_param);
/* Optional: number of registers */
no_reg = parse_no_reg(mymsg.text);
#ifdef DBG
if(dbglev>=1){
printf("Got: %s\n", mymsg.text);
printf("Parsing command:\n");
printf("Address: 0x%02x\n", address);
printf("Register: %d\n", reg_start);
printf("Register type: %d\n", regt);
printf("Register action: %d Arg: %d\n", reg_action, reg_action_param);
printf("Register count: %d\n", no_reg);
}
#endif
switch(regt) {
case MB_TYPE_COILS:
switch(reg_action) {
case ACTION_READ:
err = build_eMBMasterReadCoils (pucFrame, reg_start, reg_action_param, &usLen);
break;
case ACTION_WRITE:
err = build_eMBMasterWriteCoils (pucFrame, reg_start, reg_action_param ? 0xff : 0x0, &usLen);
break;
case ACTION_WRITEMULTIPLE:
err = build_eMBMasterWriteMultipleCoils (pucFrame, reg_start, no_reg, reg_action_param ? 0xff : 0x0, &usLen);
break;
}
break;
case MB_TYPE_INPUT:
err = build_eMBMasterReadInput (pucFrame, reg_start, reg_action_param, &usLen);
break;
case MB_TYPE_HOLDING:
switch(reg_action) {
case ACTION_READ:
err = build_eMBMasterReadHolding (pucFrame, reg_start, reg_action_param, &usLen);
break;
case ACTION_WRITE:
err = build_eMBMasterWriteSingleHolding (pucFrame, reg_start, reg_action_param, &usLen);
break;
}
break;
}
#ifdef DBG
if(dbglev){
int n;
printf("Dumping built frame:\n");
for(n=0; n<10; n++)
printf("%02x ",pucFrame[n]);
printf("\n");
}
#endif
/* ? */
eMBEnable();
memset(result, 0, sizeof(result));
if(err == MB_EX_NONE) {
/* Set the address of the device in question */
eMBSetSlaveAddress(address);
/* Send the frame */
if( (err = eMBSendFrame(pucFrame, usLen)) == MB_ENOERR) {
printf(" ---- done processing frame ----\n");
eException = MB_EX_ILLEGAL_FUNCTION;
ucFuncType = pucFrame[MB_PDU_FUNC_OFF];
#ifdef DBG
if(dbglev){
printf("%s():%d - after send...\n", __FUNCTION__, __LINE__);
{
int n;
printf("Dumping received frame:\n");
for(n=0; n<10; n++)
printf("%02x ",pucFrame[n]);
printf("\n");
}
}
#endif
if(ucFuncType & 0x80) {
UCHAR ucExceptType = pucFrame[MB_PDU_FUNC_OFF+1];
/* We encountered some sort of error */
switch(ucExceptType) {
case MB_EX_ILLEGAL_FUNCTION:
fprintf(stderr, "Error! Illegal function!\n");
break;
case MB_EX_ILLEGAL_DATA_ADDRESS:
fprintf(stderr, "Error! Illegal data address!\n");
break;
case MB_EX_ILLEGAL_DATA_VALUE:
fprintf(stderr, "Error! Illegal data value!\n");
break;
case MB_EX_SLAVE_DEVICE_FAILURE:
fprintf(stderr, "Error! Slave device failure!\n");
break;
default:
fprintf(stderr, "Unknown error (%d)!\n", eException);
break;
}
} else {
switch(ucFuncType) {
case MB_FUNC_READ_COILS:
eException = parse_eMBMasterReadCoils(pucFrame, &usLen, (void *)result);
#ifdef DBG
if(dbglev)
printf("Reply: %04x\n", result[0]);
#endif
break;
case MB_FUNC_WRITE_SINGLE_COIL:
eException = parse_eMBMasterWriteCoils(pucFrame, &usLen, (void *)result);
#ifdef DBG
if(dbglev)
printf("Reply: %04x\n", result[0]);
#endif
break;
case MB_FUNC_READ_INPUT_REGISTER:
eException = parse_eMBMasterReadInput(pucFrame, &usLen, (void *)result);
#ifdef DBG
if(dbglev)
printf("Reply (%d): %04x\n", eException, result[0]);
#endif
break;
case MB_FUNC_READ_HOLDING_REGISTER:
eException = parse_eMBMasterReadHolding(pucFrame, &usLen, (void *)result);
#ifdef DBG
printf("Reply: %04x %04x %d %d\n", result[0],result[1], result_int, reg_action_param);
#endif
break;
case MB_FUNC_WRITE_REGISTER:
eException = parse_eMBMasterWriteSingleHolding(pucFrame, &usLen, (void *)result);
#ifdef DBG
printf("Reply: %04x\n", result[0]);
#endif
break;
case MB_FUNC_WRITE_MULTIPLE_COILS:
usLen = 5;
eException = parse_eMBMasterWriteMultipleCoils(pucFrame, &usLen, (void *)result);
if(eException == MB_EX_NONE)
printf("Write multiple coils SUCCESS!\n");
else
printf("Write multiple coils FAIL!\n");
break;
default:
printf("Unknown function type : %x\n", ucFuncType);
printf("%d : %s()\n", __LINE__, __FUNCTION__);
{
int n;
for(n=0; n<10; n++)
printf("%02x ",pucFrame[n]);
printf("\n");
}
break;
}
switch(ucFuncType) {
case MB_FUNC_READ_HOLDING_REGISTER:
case MB_FUNC_READ_INPUT_REGISTER:
if(reg_action_param == 2){
printf("!!!!\n");
result_int = (result[0]<<16) | result[1];
}else {
result_int = result[0];
}
break;
default:
result_int = result[0];
break;
}
if(eException == MB_EX_NONE) {
snprintf(mymsg.text, sizeof(mymsg.text), "%ld:REG:%d:RESULT:%d", time(NULL), reg_start, result_int);
} else {
snprintf(mymsg.text, sizeof(mymsg.text), "ERROR:Parsing frame");
}
#ifdef DBG
printf("%s():%d - reply: %s\n",
__FUNCTION__, __LINE__, mymsg.text);
#endif
goto out;
}
} else {
printf("Error sending frame. (%d)\n", err);
snprintf(mymsg.text, sizeof(mymsg.text), "ERROR:Sending frame");
if(errorcount > 10)
running = 0;
else
errorcount++;
}
} else {
printf("Error in frame arguments.\n");
snprintf(mymsg.text, sizeof(mymsg.text), "ERROR:Wrong argument");
}
out:
/* Set the reply */
mymsg.type = 2;
#ifdef DBG
printf("%s():%d - reply: %s\n",
__FUNCTION__, __LINE__, mymsg.text);
#endif
msgsnd(mq_id, &mymsg, sizeof(mymsg.text), IPC_NOWAIT);
eMBDisable();
} else {
//printf("No messages. Sleeping (%d - %s)\n", received, received < 0 ? strerror(errno) : "");
}
usleep(1000);
}
// free(pucFrame);
eMBClose();
}
destroy_ipc(PROJ_ID);
pidfile_delete(pidfile);
return 0;
}
int main( int argc, char *argv[] )
{
int c;
int option_index = 0;
char *ttydev = DEFAULT_TTY;
char *parity_s = DEFAULT_PAR;
int parity;
int baud = DEFAULT_BAUD;
int reg_start = DEFAULT_REGISTER_START;
int address = DEFAULT_ADDRESS;
char *reg_type = NULL;
int regt = -1;
char *reg_action = NULL;
USHORT usLen;
UCHAR *pucFrame;
eMBErrorCode err = MB_ENOERR;
/* Parse cmd-line options */
while ( (c = getopt_long (argc, argv, "hVd:s:p:r:t:c:a:", long_options, &option_index)) != EOF ) {
switch (c) {
case 'h':
fprintf(stderr, "%s", helptext);
exit(EXIT_SUCCESS);
case 'V':
exit(EXIT_SUCCESS);
case 'd':
ttydev = strndup(optarg, MAXLEN);
break;
case 's':
baud = atoi(optarg);
break;
case 'p':
parity_s = strndup(optarg, MAXLEN);
break;
case 'r':
reg_start = (int)strtod(optarg, NULL);
break;
case 't':
reg_type = strndup(optarg, MAXLEN);
break;
case 'c':
reg_action = strndup(optarg, MAXLEN);
break;
case 'a':
address = (int)strtod(optarg, NULL);
break;
case '?':
/* getopt_long already printed an error message. */
default:
fprintf(stderr, "%s", helptext);
exit(EXIT_SUCCESS);
}
}
if(argc <= 1) {
fprintf(stderr, "%s", helptext);
exit(EXIT_FAILURE);
}
/* Allocate space for an ADU frame */
pucFrame = eMBAllocateFrame(&usLen);
/* Parse user inputs... */
if(strcmp(parity_s, "even") == 0)
parity = MB_PAR_EVEN;
else if(strcmp(parity_s, "odd") == 0)
parity = MB_PAR_ODD;
else
parity = MB_PAR_NONE;
if(reg_start < 0 || reg_start > 0xffff) {
fprintf(stderr, "Error! Modbus register out of range. Must be within (0x0-0xffff)\n");
exit(EXIT_FAILURE);
}
if(reg_type) {
if(strcmp(reg_type, "coils" ) == 0) {
regt = MB_TYPE_COILS;
} else if(strcmp(reg_type, "input" ) == 0) {
regt = MB_TYPE_INPUT;
} else if(strcmp(reg_type, "holding" ) == 0) {
regt = MB_TYPE_HOLDING;
} else if(strcmp(reg_type, "slaveid" ) == 0) {
regt = MB_TYPE_SLAVEID;
build_eMBMasterGetSlaveID (pucFrame, &usLen);
} else {
fprintf(stderr, "Error! Unknown register type (%s). Known types are: coils\n", reg_type);
exit(EXIT_FAILURE);
}
} else {
fprintf(stderr, "Error! No register type (-t) specified\n");
exit(EXIT_FAILURE);
}
if(reg_action) {
if(regt == MB_TYPE_COILS) {
if(strncmp(reg_action, "read", 4) == 0) {
int val;
if(sscanf(reg_action, "%*s %i", &val) != 1) {
fprintf(stderr, "Error! No number of coils specified.\n");
exit(EXIT_FAILURE);
}
if(val%8 == 0) {
build_eMBMasterReadCoils (pucFrame, reg_start, val, &usLen);
} else {
fprintf(stderr, "Error! Invalid coil value (%d). Must be a multiple of 8.\n", val);
exit(EXIT_FAILURE);
}
} else if(strncmp(reg_action, "writesingle", 11) == 0) {
char buf[4];
if(sscanf(reg_action, "%*s %3[FNO]", buf) != 1) {
fprintf(stderr, "Error! No coil value specified (ON/OFF).\n");
exit(EXIT_FAILURE);
}
if(strcmp(buf, "ON") == 0)
build_eMBMasterWriteCoils (pucFrame, reg_start, 0xff, &usLen);
else
build_eMBMasterWriteCoils (pucFrame, reg_start, 0x0, &usLen);
} else if(strncmp(reg_action, "writemultiple", 13) == 0) {
int no;
char buf[4];
if( sscanf(reg_action, "%*s %i %3[FNO]", &no, buf) != 2) {
fprintf(stderr, "Error! Invalid value specified.\n");
exit(EXIT_FAILURE);
}
if(strcmp(buf, "ON") == 0)
build_eMBMasterWriteMultipleCoils (pucFrame, reg_start, no, 0xff, &usLen);
else
build_eMBMasterWriteMultipleCoils (pucFrame, reg_start, no, 0x0, &usLen);
} else {
fprintf(stderr, "Error! Unknown command type (%s).\n", reg_action);
exit(EXIT_FAILURE);
}
} else if(regt == MB_TYPE_INPUT) {
if(strncmp(reg_action, "read", 4) == 0) {
int val;
if(sscanf(reg_action, "%*s %i", &val) != 1) {
fprintf(stderr, "Error! No number of registers specified.\n");
exit(EXIT_FAILURE);
}
if(build_eMBMasterReadInput (pucFrame, reg_start, val, &usLen) != MB_ENOERR) {
fprintf(stderr, "Error! Wrong register count. Must be between 1 and 125 (0x7d)\n");
exit(EXIT_FAILURE);
}
}
} else if(regt == MB_TYPE_HOLDING) {
if(strncmp(reg_action, "read", 4) == 0) {
int val;
if(sscanf(reg_action, "%*s %i", &val) != 1) {
fprintf(stderr, "Error! No number of registers specified.\n");
exit(EXIT_FAILURE);
}
if(build_eMBMasterReadHolding (pucFrame, reg_start, val, &usLen) != MB_ENOERR) {
fprintf(stderr, "Error! Wrong register count. Must be between 1 and 125 (0x7d)\n");
exit(EXIT_FAILURE);
}
printf("%s():%d - build_eMBMasterReadHolding(pucFramem, %d, %d, %d)\n",
__FUNCTION__, __LINE__,
reg_start, val, usLen);
} else if(strncmp(reg_action, "writesingle", 11) == 0) {
int val;
if( sscanf(reg_action, "%*s %i", &val) != 1) {
fprintf(stderr, "Error! Invalid value specified.\n");
exit(EXIT_FAILURE);
}
if(build_eMBMasterWriteSingleHolding (pucFrame, reg_start, val, &usLen) != MB_ENOERR) {
fprintf(stderr, "Error!\n");
exit(EXIT_FAILURE);
}
}
}
} else {
fprintf(stderr, "Error! No command (-c) specified.\n");
exit(EXIT_FAILURE);
}
/* mode, port, baud, parity */
eMBMasterInit(MB_RTU, ttydev, baud, parity);
/* ? */
eMBEnable();
/* Set the address of the device in question */
eMBSetSlaveAddress(address);
/* Send the frame */
if( (err = eMBSendFrame(pucFrame, usLen)) != MB_ENOERR) {
printf("Error sending frame (%d).\n", err);
exit(EXIT_FAILURE);
}
eMBException eException;
eException = MB_EX_ILLEGAL_FUNCTION;
UCHAR ucFuncType = pucFrame[MB_PDU_FUNC_OFF];
USHORT retval[255];
if(ucFuncType & 0x80) {
UCHAR ucExceptType = pucFrame[MB_PDU_FUNC_OFF+1];
/* We encountered some sort of error */
switch(ucExceptType) {
case MB_EX_ILLEGAL_FUNCTION:
fprintf(stderr, "Error! Illegal function!\n");
break;
case MB_EX_ILLEGAL_DATA_ADDRESS:
fprintf(stderr, "Error! Illegal data address!\n");
break;
case MB_EX_ILLEGAL_DATA_VALUE:
fprintf(stderr, "Error! Illegal data value!\n");
break;
case MB_EX_SLAVE_DEVICE_FAILURE:
fprintf(stderr, "Error! Slave device failure!\n");
break;
default:
fprintf(stderr, "Unknown error (%d)!\n", eException);
break;
}
} else {
switch(ucFuncType) {
case MB_FUNC_READ_COILS:
eException = parse_eMBMasterReadCoils(pucFrame, &usLen, (void *)retval);
printf("Reply: %04x\n", retval[0]);
break;
case MB_FUNC_WRITE_SINGLE_COIL:
eException = parse_eMBMasterWriteCoils(pucFrame, &usLen, (void *)retval);
printf("Reply: %04x\n", retval[0]);
break;
case MB_FUNC_READ_INPUT_REGISTER:
eException = parse_eMBMasterReadInput(pucFrame, &usLen, (void *)retval);
printf("Reply (%d): %04x\n", eException, retval[0]);
break;
case MB_FUNC_READ_HOLDING_REGISTER:
eException = parse_eMBMasterReadHolding(pucFrame, &usLen, (void *)retval);
printf("Reply: %04x\n", retval[0]);
break;
case MB_FUNC_WRITE_REGISTER:
eException = parse_eMBMasterWriteSingleHolding(pucFrame, &usLen, (void *)retval);
printf("Reply: %04x\n", retval[0]);
break;
case MB_FUNC_WRITE_MULTIPLE_COILS:
usLen = 5;
eException = parse_eMBMasterWriteMultipleCoils(pucFrame, &usLen, (void *)retval);
if(eException == MB_EX_NONE)
printf("Write multiple coils SUCCESS!\n");
else
printf("Write multiple coils FAIL!\n");
break;
default:
printf("Unknown function type : %x\n", ucFuncType);
printf("%d : %s()\n", __LINE__, __FUNCTION__);
{
int n;
for(n=0; n<10; n++)
printf("%02x ",pucFrame[n]);
printf("\n");
}
break;
}
}
#ifdef DBG
printf("%d : %s()\n", __LINE__, __FUNCTION__);
{
int j;
for(j=0; j<usLen; j++)
printf("%02x ", pucFrame[j]);
printf("\n");
}
#endif
eMBClose();
return 0;
}
__noreturn main()
{
RCC_Config();
//I2C_Enable();
SPI_Enable();
GPIO_Enable();
//ADC_Enable();
MTouchInit();
MTouchSetSensor(0, CH0_TRIS, CH0_LAT, CH0_IO_BIT, CH0_AN_NUM, -1, -1, -1,OUT_CH0_MODER,IN_CH0_MODER,AN_CH0_MODER);// sensor #0
MTouchSetSensor(1, CH1_TRIS, CH1_LAT, CH1_IO_BIT, CH1_AN_NUM, -1, -1, -1,OUT_CH1_MODER,IN_CH1_MODER,AN_CH1_MODER);// sensor #1
MTouchSetSensor(2, CH2_TRIS, CH2_LAT, CH2_IO_BIT, CH2_AN_NUM, -1, -1, -1,OUT_CH2_MODER,IN_CH2_MODER,AN_CH2_MODER);// sensor #2
MTouchSetSensor(3, CH3_TRIS, CH3_LAT, CH3_IO_BIT, CH3_AN_NUM, -1, -1, -1,OUT_CH3_MODER,IN_CH3_MODER,AN_CH3_MODER);// sensor #3
// thr ovs cd
MTouchSetButton(0, 0, DECODE_PRESS_RELEASE|DECODE_ONE_EVENT);
MTouchSetButton(1, 1, DECODE_PRESS_RELEASE|DECODE_ONE_EVENT);
MTouchSetButton(2, 2, DECODE_PRESS_RELEASE|DECODE_ONE_EVENT);
MTouchSetButton(3, 3, DECODE_PRESS_RELEASE|DECODE_ONE_EVENT);
Timers_init();
#ifdef __MOD_BUS_ENABLE__
eMBMasterInit(MB_RTU, 2, 38400, MB_PAR_NONE);
eMBMasterEnable();
#endif /*__MOD_BUS_ENABLE__*/
__enable_irq();
//*******************Потом заменим на чтение из EEPROM*******************
up_led(1);
bottom_led(0);
chasy_led_string("er");
minuty_led_string("r");
Indic_struct.colon = False;
//************************************************************************
while (1)
{
#ifdef __MOD_BUS_ENABLE__
eMBMasterPoll();
#endif /*__MOD_BUS_ENABLE__*/
#ifdef __SENSOR_KEYS__
MTouchDecode();
#endif /*__SENSOR_KEYS__*/
#ifdef __TOUCH_DEBUG__
up_led(buttons[0].pSensor->delta/10);
chasy_led(buttons[1].pSensor->delta/10);
minuty_led(buttons[2].pSensor->delta/10);
bottom_led(buttons[3].pSensor->delta/10);
if(buttons[0].curState == 0x01){Indic_struct.k4 = True;} else {Indic_struct.k4 = False;};
if(buttons[1].curState == 0x01){Indic_struct.k3 = True;} else {Indic_struct.k3 = False;};
if(buttons[2].curState == 0x01){Indic_struct.k2 = True;} else {Indic_struct.k2 = False;};
if(buttons[3].curState == 0x01){Indic_struct.k1 = True;} else {Indic_struct.k1 = False;};
#endif /*__TOUCH_DEBUG__*/
// if (o < 7 ) {o++;} else {/*o = 0;*/};
// switch(o)
// {
// case 0:
// Indic_struct.k1 = True;
// break;
// case 1:
// Indic_struct.k2 = True;
// break;
// case 2:
// Indic_struct.k3 = True;
// break;
// case 3:
// Indic_struct.k4 = True;
// break;
// case 4:
// Indic_struct.red_bottom = True;
// break;
// case 5:
// //Indic_struct.minus = True;
// break;
// case 6:
// Indic_struct.red_up = True;
// break;
// case 100:
// Indic_struct.k1 = False;
// Indic_struct.k2 = False;
// Indic_struct.k3 = False;
// Indic_struct.k4 = False;
// Indic_struct.red_bottom = False;
// Indic_struct.minus = False;
// Indic_struct.red_up = False;
// break;
// default:
// break;
// };
//
// for(uint16_t f=0;f<60000;f++){ for(uint16_t f=0;f<50;f++){};};
//
// Indic_struct.minuty++;
//
//
//
// //Indic_struct.blink_chasy = True;
// Indic_struct.blink_k2 = True;
// Indic_struct.blink_minus = False;
// //Indic_struct.blink_minuty = True;
// Indic_struct.blink_verhniy_indicator = True;
// Indic_struct.blink_colon = True;
};
//return 0;
}
