26 #define BPS_TIMEOUT_MS 2000
34 #define BPS_MAX_RET_LEN 80
35 #define BPS_MAX_CMD_LEN 80
37 static unsigned char _BpsCmdBuf[BPS_MAX_CMD_LEN];
38 static unsigned char _retBpsCmdBuf[BPS_MAX_RET_LEN];
45 #define _BPS_USHORT_SIZE 4
46 #define _BPS_UCHAR_SIZE 2
50 #define _BPSCMD_SwitchControl_Request 0x40
51 #define _BPSCMD_SwitchControl_Answer 0x41
52 #define _BPSCMD_AlarmEnable_Request 0x42
53 #define _BPSCMD_AlarmEnable_Answer 0x43
54 #define _BPSCMD_AlarmTimeOut_Save_Request 0x44
55 #define _BPSCMD_AlarmTimeOut_Save_Answer 0x45
56 #define _BPSCMD_AlarmTimeOut_Load_Request 0x46
57 #define _BPSCMD_AlarmTimeOut_Load_Answer 0x47
58 #define _BPSCMD_Alarm_Threshold_Save_Request 0x4C
59 #define _BPSCMD_Alarm_Threshold_Save_Answer 0x4D
60 #define _BPSCMD_Alarm_Threshold_Load_Request 0x4E
61 #define _BPSCMD_Alarm_Threshold_Load_Answer 0x4F
62 #define _BPSCMD_Alarm_Fired_Get_Request 0x50
63 #define _BPSCMD_Alarm_Fired_Get_Answer 0x51
64 #define _BPSCMD_ReadSensorsSingle_Request 0x56
65 #define _BPSCMD_ReadSensorsSingle_Answer 0x57
66 #define _BPSCMD_SensorMaxvalueReset_Request 0x58
67 #define _BPSCMD_SensorMaxvalueReset_Answer 0x59
68 #define _BPSCMD_ReadSensors_Request 0x5a
69 #define _BPSCMD_ReadSensors_Answer 0x5b
70 #define _BPSCMD_ReadSensorsAverage_Request 0x5c
71 #define _BPSCMD_ReadSensorsAverage_Answer 0x5d
72 #define _BPSCMD_ReadSensorsMax_Request 0x60
73 #define _BPSCMD_ReadSensorsMax_Answer 0x61
74 #define _BPSCMD_ReadVersion_Request 0x6a
75 #define _BPSCMD_ReadVersion_Answer 0x6b
76 #define _BPSCMD_Rescue_Enable_Request 0x6e
77 #define _BPSCMD_Rescue_Enable_Answer 0x6f
94 #define _BPSCMD_Error_Chk 0x02
95 #define _BPSCMD_Error_Start 0x04
96 #define _BPSCMD_Error_Timeout 0x08
123 #define SIZE_THRESHOLD (NTHRESHOLD * _BPS_USHORT_SIZE)
131 static const BpsCmd BSP_CMD_INIT = {BPS_ADDR,0x0,0x0,0x0};
133 static const CnvParams _hex = CNV_DEFAULT_HEX;
195 bool _bpsIn(
char *c );
196 void _bpsOut(
char c);
197 unsigned char bpschecksum(
unsigned char* buff,
int num);
198 unsigned char s_bpschecksum(
BpsAnsw* answ);
199 void _bpsCmdTx (
int nBytes);
200 bool _bpsRxCommand(
BpsAnsw* answ);
201 int _bpsBufferCmd(
BpsCmd* _cmd);
202 bool _bpsCmdRxCheck(uint8_t answ,
BpsAnsw* s_answ);
203 bool _bpsTxAndRx(
BpsCmd *pcmd,
BpsAnsw* pansw, uint8_t cansw);
210 bool _bpsIn(
char *c )
213 if(
bfEmpty(BPS_UART->rxfifo))
return false;
216 bfRead(BPS_UART->rxfifo,(uint8_t*) c);
220 printf(
"rx -> 0x%x (%d)\n",*c,*c);
235 printf(
"tx -> 0x%x (%d)\n",c,c);
242 unsigned char bpschecksum(
unsigned char* buff,
int num)
245 unsigned char chk = 256;
256 unsigned char s_bpschecksum(
BpsAnsw* answ)
261 chk = bpschecksum(answ->pData, answ->nData);
263 chk -= answ->hf.addr ;
264 chk -= answ->hf.cmd ;
271 void _bpsCmdTx (
int nBytes)
274 assert(nBytes < BPS_MAX_CMD_LEN);
284 _bpsOut(_BpsCmdBuf[i]);
288 _bpsOut(bpschecksum(_BpsCmdBuf,nBytes));
297 bool _bpsRxCommand(
BpsAnsw* answ)
301 assert(answ->nData +
sizeof(
BpsAnswFix) < BPS_MAX_RET_LEN);
306 bool isFrame =
false;
309 while(i< (answ->nData +
sizeof(
BpsAnswFix) )){
313 printf(
"Error timeout \n");
317 if(c == _BPS_SOF || isFrame){
318 _retBpsCmdBuf[i] = (
unsigned char) c;
335 _retBpsCmdBuf[0] = _BPS_SOF;
336 _retBpsCmdBuf[1] = _BpsCmdBuf[0];
339 if(_BpsCmdBuf[1] == _BPSCMD_ReadSensors_Request){
340 _retBpsCmdBuf[2] = _BPSCMD_ReadSensors_Answer;
341 _retBpsCmdBuf[3] =
'1';
342 _retBpsCmdBuf[4] =
'2';
343 _retBpsCmdBuf[5] =
'3';
344 _retBpsCmdBuf[6] =
'4';
345 _retBpsCmdBuf[7] =
'5';
346 _retBpsCmdBuf[8] =
'6';
347 _retBpsCmdBuf[9] =
'7';
348 _retBpsCmdBuf[10] =
'8';
349 _retBpsCmdBuf[11] =
'9';
350 _retBpsCmdBuf[12] =
'a';
351 _retBpsCmdBuf[13] =
'b';
352 _retBpsCmdBuf[14] =
'c';
353 _retBpsCmdBuf[15] =
'd';
354 _retBpsCmdBuf[16] =
'e';
355 _retBpsCmdBuf[17] =
'f';
356 _retBpsCmdBuf[18] =
'0';
357 _retBpsCmdBuf[19] =
'1';
358 _retBpsCmdBuf[20] =
'2';
359 _retBpsCmdBuf[21] =
'3';
360 _retBpsCmdBuf[22] =
'4';
361 _retBpsCmdBuf[23] =
'5';
362 _retBpsCmdBuf[24] =
'6';
363 _retBpsCmdBuf[25] =
'7';
364 _retBpsCmdBuf[26] =
'8';
365 _retBpsCmdBuf[27] =
'9';
366 _retBpsCmdBuf[28] =
'a';
367 _retBpsCmdBuf[29] =
'b';
368 _retBpsCmdBuf[30] =
'c';
369 _retBpsCmdBuf[31] =
'd';
370 _retBpsCmdBuf[32] =
'e';
371 _retBpsCmdBuf[33] =
'f';
372 _retBpsCmdBuf[34] =
'0';
373 _retBpsCmdBuf[35] = bpschecksum(_retBpsCmdBuf+1,34);
374 _retBpsCmdBuf[36] = _BPS_EOF;
377 else if(_BpsCmdBuf[1] == _BPSCMD_Alarm_Enable_Load_Request){
378 _retBpsCmdBuf[2] = _BPSCMD_Alarm_Enable_Load_Answer;
379 _retBpsCmdBuf[3] =
'1';
380 _retBpsCmdBuf[4] =
'2';
381 _retBpsCmdBuf[5] =
'3';
382 _retBpsCmdBuf[6] =
'4';
383 _retBpsCmdBuf[7] = bpschecksum(_retBpsCmdBuf+1,6);
384 _retBpsCmdBuf[8] = _BPS_EOF;
386 else if(_BpsCmdBuf[1] == _BPSCMD_Alarm_Enable_Save_Request){
387 _retBpsCmdBuf[2] = _BPSCMD_Alarm_Enable_Save_Answer;
388 _retBpsCmdBuf[3] = _BpsCmdBuf[2];
389 _retBpsCmdBuf[4] = _BpsCmdBuf[3];
390 _retBpsCmdBuf[5] = _BpsCmdBuf[4];
391 _retBpsCmdBuf[6] = _BpsCmdBuf[5];
392 _retBpsCmdBuf[7] = bpschecksum(_retBpsCmdBuf+1,6);
393 _retBpsCmdBuf[8] = _BPS_EOF;
395 else if(_BpsCmdBuf[1] == _BPSCMD_Alarm_ClearStatus_Request){
396 _retBpsCmdBuf[2] = _BPSCMD_Alarm_ClearStatus_Answer;
397 _retBpsCmdBuf[3] =
'1';
398 _retBpsCmdBuf[4] =
'2';
399 _retBpsCmdBuf[5] =
'3';
400 _retBpsCmdBuf[6] =
'4';
401 _retBpsCmdBuf[7] = bpschecksum(_retBpsCmdBuf+1,6);
402 _retBpsCmdBuf[8] = _BPS_EOF;
404 else if(_BpsCmdBuf[1] == _BPSCMD_Alarm_Threshold_Load_Request){
405 _retBpsCmdBuf[2] = _BPSCMD_Alarm_Threshold_Load_Answer;
406 _retBpsCmdBuf[3] =
'1';
407 _retBpsCmdBuf[4] =
'2';
408 _retBpsCmdBuf[5] =
'3';
409 _retBpsCmdBuf[6] =
'4';
410 _retBpsCmdBuf[7] =
'1';
411 _retBpsCmdBuf[8] =
'2';
412 _retBpsCmdBuf[9] =
'3';
413 _retBpsCmdBuf[10] =
'4';
414 _retBpsCmdBuf[11] = bpschecksum(_retBpsCmdBuf+1,10);
415 _retBpsCmdBuf[12] = _BPS_EOF;
417 else if(_BpsCmdBuf[1] == _BPSCMD_Alarm_Threshold_Save_Request){
418 _retBpsCmdBuf[2] = _BPSCMD_Alarm_Threshold_Save_Answer;
419 _retBpsCmdBuf[3] = _BpsCmdBuf[2];
420 _retBpsCmdBuf[4] = _BpsCmdBuf[3];
421 _retBpsCmdBuf[5] = _BpsCmdBuf[4];
422 _retBpsCmdBuf[6] = _BpsCmdBuf[5];
423 _retBpsCmdBuf[7] = _BpsCmdBuf[6];
424 _retBpsCmdBuf[8] = _BpsCmdBuf[7];
425 _retBpsCmdBuf[9] = _BpsCmdBuf[8];
426 _retBpsCmdBuf[10] = _BpsCmdBuf[9];
427 _retBpsCmdBuf[11] = bpschecksum(_retBpsCmdBuf+1,10);
428 _retBpsCmdBuf[12] = _BPS_EOF;
430 else if(_BpsCmdBuf[1] == _BPSCMD_ReleToggle_Ixx_Request){
431 _retBpsCmdBuf[2] = _BPSCMD_ReleToggle_Ixx_Answer;
432 _retBpsCmdBuf[3] = 0x31;
433 _retBpsCmdBuf[4] = 0x30;
434 _retBpsCmdBuf[5] = 0x30;
435 _retBpsCmdBuf[6] = 0x30;
436 _retBpsCmdBuf[7] = bpschecksum(_retBpsCmdBuf+1,6);
437 _retBpsCmdBuf[8] = _BPS_EOF;
439 else if(_BpsCmdBuf[1] == _BPSCMD_PingDevice_Request){
440 _retBpsCmdBuf[2] = _BPSCMD_PingDevice_Answer;
441 _retBpsCmdBuf[3] =
'1';
442 _retBpsCmdBuf[4] =
'2';
443 _retBpsCmdBuf[5] =
'3';
444 _retBpsCmdBuf[6] =
'4';
445 _retBpsCmdBuf[7] = bpschecksum(_retBpsCmdBuf+1,6);
446 _retBpsCmdBuf[8] = _BPS_EOF;
455 answ->hf.sof = _retBpsCmdBuf[0];
456 answ->hf.addr = _retBpsCmdBuf[1];
457 answ->hf.cmd = _retBpsCmdBuf[2];
458 answ->pData = &_retBpsCmdBuf[3];
459 answ->hf.chk = _retBpsCmdBuf[3+answ->nData];
460 answ->hf.eof = _retBpsCmdBuf[4+answ->nData];
468 int _bpsBufferCmd(
BpsCmd* _cmd)
471 assert(_cmd->nData + 2 < BPS_MAX_CMD_LEN);
472 _BpsCmdBuf[0] = _cmd->addr;
473 _BpsCmdBuf[1] = _cmd->cmd;
474 if(_cmd->nData && _cmd->pData)memcpy ( _BpsCmdBuf+2, _cmd->pData, _cmd->nData );
476 return (_cmd->nData + 2);
481 bool _bpsCmdRxCheck(uint8_t answ,
BpsAnsw* s_answ)
484 if(s_answ->hf.sof != _BPS_SOF){
489 if(s_bpschecksum(s_answ) != s_answ->hf.chk ){
494 if(s_answ->hf.eof != _BPS_EOF){
500 if(BPS_ADDR != s_answ->hf.addr){
504 if(s_answ->hf.cmd == answ)
return true;
506 switch(s_answ->hf.cmd){
507 case _BPSCMD_Error_Chk:
510 case _BPSCMD_Error_Start:
513 case _BPSCMD_Error_Timeout:
527 _bpsCmdTx (_bpsBufferCmd(pcmd));
528 if(_bpsRxCommand(pansw))
return _bpsCmdRxCheck(cansw,pansw);
533 uint16_t _bpsHexAscii2Short(uint8_t* input)
536 char crev[_BPS_USHORT_SIZE];
539 for(j=0;j<_BPS_USHORT_SIZE;j++){
548 if (
cnvParseU(crev, &lb, _hex) == 0)
return 0x0;
550 return (uint16_t) (lb & 0xFFFF);
553 uint8_t _bpsHexAscii2Char(uint8_t* input)
556 char crev[_BPS_UCHAR_SIZE];
559 for(j=0;j<_BPS_UCHAR_SIZE;j++){
568 if (
cnvParseU(crev, &lb, _hex) == 0)
return 0x0;
570 return (uint8_t) (lb & 0xFFFF);
573 void _bpsShort2HexAscii(uint16_t sdata, uint8_t* input)
576 char outstring[2*_BPS_USHORT_SIZE];
581 if(
cnvFormatU( (int32_t) sdata, outstring,_hex) == 0)
return;
586 while(outstring[j] !=
'\0' && j<2*_BPS_USHORT_SIZE)
593 if (j < _BPS_USHORT_SIZE)
598 for(k=_BPS_USHORT_SIZE-j;k<_BPS_USHORT_SIZE;k++){
599 input[k]=outstring[k+j-_BPS_USHORT_SIZE];
606 for(k=0;k<_BPS_USHORT_SIZE;k++){
607 input[k]=outstring[k];
620 void _bpsChar2HexAscii(uint8_t sdata, uint8_t* input)
623 char outstring[2*_BPS_UCHAR_SIZE];
628 if(
cnvFormatU( (int32_t) sdata, outstring,_hex) == 0)
return;
632 while(outstring[j] !=
'\0' && j<2*_BPS_UCHAR_SIZE)
639 if (j < _BPS_UCHAR_SIZE)
645 for(k=_BPS_UCHAR_SIZE-j;k<_BPS_UCHAR_SIZE;k++){
646 input[k]=outstring[k+j-_BPS_UCHAR_SIZE];
652 for(k=0;k<_BPS_UCHAR_SIZE;k++){
653 input[k]=outstring[k];
669 uint8_t sData[_BPS_USHORT_SIZE + _BPS_UCHAR_SIZE];
672 BpsCmd cmd = BSP_CMD_INIT;
673 cmd.cmd = _BPSCMD_AlarmTimeOut_Save_Request;
674 cmd.nData = _BPS_USHORT_SIZE + _BPS_UCHAR_SIZE;
682 _bpsChar2HexAscii(time_out_ch,sData);
684 _bpsShort2HexAscii(time_out_val,sData+_BPS_UCHAR_SIZE);
687 if(!_bpsTxAndRx(&cmd,&ans, _BPSCMD_AlarmTimeOut_Save_Answer))
return false;
736 uint8_t sData[_BPS_UCHAR_SIZE];
737 BpsCmd cmd = BSP_CMD_INIT;
738 cmd.cmd = _BPSCMD_ReadSensorsSingle_Request;
739 cmd.nData = _BPS_UCHAR_SIZE;
749 _bpsChar2HexAscii(single_var,sData);
751 if(!_bpsTxAndRx(&cmd,&ans, _BPSCMD_ReadSensorsSingle_Answer))
return false;
753 pvar = _bpsHexAscii2Char(ans.pData);
756 pRet[i] = _bpsHexAscii2Short(ans.pData+_BPS_UCHAR_SIZE+i*_BPS_USHORT_SIZE);
760 stat->single_var_num = pvar;
761 stat->single_value = pRet[0];
762 stat->single_offset = pRet[1];
763 stat->single_maxval = pRet[2];
764 stat->single_meanval = pRet[3];
776 BpsCmd cmd = BSP_CMD_INIT;
777 cmd.cmd = _BPSCMD_ReadSensorsAverage_Request;
784 if(!_bpsTxAndRx(&cmd,&ans, _BPSCMD_ReadSensorsAverage_Answer))
return false;
788 pRet[i] = _bpsHexAscii2Short(ans.pData+i*_BPS_USHORT_SIZE);
792 stat->mon_5V_i_M = pRet[0];
793 stat->mon_LBL_i_M = pRet[1];
794 stat->mon_DU_i_M = pRet[2];
795 stat->mon_DU_irtn_M = pRet[3];
796 stat->mon_BPS_v_M = pRet[4];
797 stat->mon_HYDRO_i_M = pRet[5];
798 stat->mon_MON_THEATSINK_M = pRet[6];
799 stat->mon_TBOARD_M = pRet[7];
813 BpsCmd cmd = BSP_CMD_INIT;
814 cmd.cmd = _BPSCMD_ReadSensors_Request;
822 if(!_bpsTxAndRx(&cmd,&ans, _BPSCMD_ReadSensors_Answer))
return false;
826 pRet[i] = _bpsHexAscii2Short(ans.pData+i*_BPS_USHORT_SIZE);
832 pRet2[i] = _bpsHexAscii2Char(ans.pData+8*_BPS_USHORT_SIZE+i*_BPS_UCHAR_SIZE);
836 stat->mon_5V_i = pRet[0];
837 stat->mon_LBL_i = pRet[1];
838 stat->mon_DU_i = pRet[2];
839 stat->mon_DU_irtn = pRet[3];
840 stat->mon_BPS_v = pRet[4];
841 stat->mon_HYDRO_i = pRet[5];
842 stat->mon_MON_THEATSINK = pRet[6];
843 stat->mon_TBOARD = pRet[7];
844 stat->mon_ALRMPOS1 = pRet2[0];
845 stat->mon_ALRMPOS2 = pRet2[1];
846 stat->mon_ALRMNEG1 = pRet2[2];
847 stat->mon_ALRMNEG2 = pRet2[3];
860 BpsCmd cmd = BSP_CMD_INIT;
861 cmd.cmd = _BPSCMD_ReadSensorsMax_Request;
869 if(!_bpsTxAndRx(&cmd,&ans, _BPSCMD_ReadSensorsMax_Answer))
return false;
873 pRet[i] = _bpsHexAscii2Short(ans.pData+i*_BPS_USHORT_SIZE);
879 pRet2[i] = _bpsHexAscii2Char(ans.pData+8*_BPS_USHORT_SIZE+i*_BPS_UCHAR_SIZE);
883 stat->mon_5V_i = pRet[0];
884 stat->mon_LBL_i = pRet[1];
885 stat->mon_DU_i = pRet[2];
886 stat->mon_DU_irtn = pRet[3];
887 stat->mon_BPS_v = pRet[4];
888 stat->mon_HYDRO_i = pRet[5];
889 stat->mon_MON_THEATSINK = pRet[6];
890 stat->mon_TBOARD = pRet[7];
891 stat->mon_ALRMPOS1 = pRet2[0];
892 stat->mon_ALRMPOS2 = pRet2[1];
893 stat->mon_ALRMNEG1 = pRet2[2];
894 stat->mon_ALRMNEG2 = pRet2[3];
950 bool bpsAlarmThLoadV3(uint8_t th_channel,
BspThV3 *th)
953 uint8_t sData[_BPS_UCHAR_SIZE];
954 BpsCmd cmd = BSP_CMD_INIT;
955 cmd.cmd = _BPSCMD_Alarm_Threshold_Load_Request;
956 cmd.nData = _BPS_UCHAR_SIZE;
960 uint16_t rawth[NTHRESHOLD];
962 uint16_t th_alarm_val;
969 _bpsChar2HexAscii(th_channel,sData);
972 if(!_bpsTxAndRx(&cmd,&ans, _BPSCMD_Alarm_Threshold_Load_Answer))
return false;
974 th_alarm_ch = _bpsHexAscii2Char(ans.pData);
975 th_alarm_val= _bpsHexAscii2Short(ans.pData+_BPS_UCHAR_SIZE);
980 th->thr_alarm_ch = th_alarm_ch ;
981 th->thr_alarm_val = th_alarm_val;
991 bool bpsAlarmThSaveV3(uint8_t al_th_ch, uint16_t al_th_val){
994 uint8_t sData[_BPS_USHORT_SIZE + _BPS_UCHAR_SIZE];
999 BpsCmd cmd = BSP_CMD_INIT;
1000 cmd.cmd = _BPSCMD_Alarm_Threshold_Save_Request;
1001 cmd.nData = _BPS_USHORT_SIZE + _BPS_UCHAR_SIZE;
1006 _bpsChar2HexAscii(al_th_ch,sData);
1007 _bpsShort2HexAscii(al_th_val,sData+_BPS_UCHAR_SIZE);
1008 if(!_bpsTxAndRx(&cmd,&ans, _BPSCMD_Alarm_Threshold_Save_Answer))
return false;
1018 uint8_t sData[2*_BPS_UCHAR_SIZE];
1021 BpsCmd cmd = BSP_CMD_INIT;
1022 cmd.cmd = _BPSCMD_SwitchControl_Request;
1023 cmd.nData = 2*_BPS_UCHAR_SIZE;
1026 ans.nData = 2*_BPS_UCHAR_SIZE;
1030 _bpsChar2HexAscii(ch,sData);
1032 _bpsChar2HexAscii(val,sData+_BPS_UCHAR_SIZE);
1034 if(!_bpsTxAndRx(&cmd,&ans, _BPSCMD_SwitchControl_Answer))
return false;
1036 sw_rd->sw_control_ch = _bpsHexAscii2Char(ans.pData);
1037 sw_rd->sw_control_val = _bpsHexAscii2Char(ans.pData+_BPS_UCHAR_SIZE);
1049 assert(AlarmFiredGet);
1051 uint8_t sData[_BPS_UCHAR_SIZE];
1052 BpsCmd cmd = BSP_CMD_INIT;
1053 cmd.cmd = _BPSCMD_Alarm_Fired_Get_Request;
1054 cmd.nData = _BPS_UCHAR_SIZE;
1057 ans.nData = 2*_BPS_UCHAR_SIZE;
1059 _bpsChar2HexAscii(ch,sData);
1061 if(!_bpsTxAndRx(&cmd,&ans, _BPSCMD_Alarm_Fired_Get_Answer))
return false;
1063 AlarmFiredGet->alarm_ch = _bpsHexAscii2Char(ans.pData) ;
1064 AlarmFiredGet->alarm_val = _bpsHexAscii2Char(ans.pData+_BPS_UCHAR_SIZE);
1078 uint8_t sData[2*_BPS_UCHAR_SIZE];
1081 BpsCmd cmd = BSP_CMD_INIT;
1082 cmd.cmd = _BPSCMD_AlarmEnable_Request;
1083 cmd.nData = 2*_BPS_UCHAR_SIZE;
1086 ans.nData = 2*_BPS_UCHAR_SIZE;
1090 _bpsChar2HexAscii(ch,sData);
1092 _bpsChar2HexAscii(val,sData+_BPS_UCHAR_SIZE);
1094 if(!_bpsTxAndRx(&cmd,&ans, _BPSCMD_AlarmEnable_Answer))
return false;
1096 AlarmEn_rd->alarm_ch = _bpsHexAscii2Char(ans.pData) ;
1097 AlarmEn_rd->alarm_val = _bpsHexAscii2Char(ans.pData+_BPS_UCHAR_SIZE);
1108 uint8_t sData[_BPS_UCHAR_SIZE];
1109 BpsCmd cmd = BSP_CMD_INIT;
1110 cmd.cmd = _BPSCMD_Rescue_Enable_Request;
1111 cmd.nData = _BPS_UCHAR_SIZE;
1114 ans.nData = _BPS_UCHAR_SIZE;
1118 _bpsChar2HexAscii(set_val,sData);
1121 if(!_bpsTxAndRx(&cmd,&ans, _BPSCMD_Rescue_Enable_Answer))
return false;
1123 *rd_val = _bpsHexAscii2Char(ans.pData) ;
1131 uint8_t sData[_BPS_UCHAR_SIZE];
1132 BpsCmd cmd = BSP_CMD_INIT;
1133 cmd.cmd = _BPSCMD_SensorMaxvalueReset_Request;
1134 cmd.nData = _BPS_UCHAR_SIZE;
1141 _bpsChar2HexAscii(set_val,sData);
1144 if(!_bpsTxAndRx(&cmd, &ans, _BPSCMD_SensorMaxvalueReset_Answer))
return false;
1172 bool bpsDbgCmdReply(uint8_t cmdCode, uint8_t * cmdPData, uint8_t cmdNData,
1173 uint8_t rplCode, uint8_t ** rplPData, uint8_t rplNData)
1175 BpsCmd cmd = BSP_CMD_INIT ;
1178 cmd.pData = cmdPData;
1179 cmd.nData = cmdNData;
1180 ans.nData = rplNData;
1182 if (!_bpsTxAndRx(&cmd, &ans, rplCode))
return false;
1184 *rplPData = ans.pData;
int cnvFormatU(int32_t input, char *output, CnvParams params)
Formats an unsigned integer into a character buffer.
bool bpsSwitchControlV3(uint8_t ch, uint8_t val, SwCtrlV3 *sw_rd)
switch control
bool bpsReadSensorMaxV3(BpsRdSensAnswV3 *stat)
return all sensors' max values
bool bpsRescueEnable(uint8_t set_val, uint8_t *rd_val)
Version.
bool bpsAlarmFiredGetV3(uint8_t ch, BpsAlarmV3 *AlarmFiredGet)
Return flag of one alarm.
static bool bfEmpty(ByteFifo *const bf)
Returns whether or not the byte-fifo is empty.
bool bpsDbgCmdReply(uint8_t cmdCode, uint8_t *cmdPData, uint8_t cmdNData, uint8_t rplCode, uint8_t **rplPData, uint8_t rplNData)
Exposes the low-level interface to the BPS.
static void __irqEnable()
Enabled IRQ's on a global level.
int cnvParseU(const char *input, uint32_t *output, CnvParams params)
Parse an unsigned integer.
static void __irqDisable()
Disables IRQ's on a global level.
bool bpsSensorMaxvalueReset(uint8_t set_val)
SENSOR_MAXVALUE_RESET set_val : Variable number.
bool bpsAlarmTimeOutSaveV3(uint8_t time_out_ch, uint16_t time_out_val)
Set the threshold value of one analog alarm.
#define E_BPS_TIMEOUT
Receive timeout.
static uint32_t timeOutInit(uint32_t msec)
Initializes a timeout with the specified no of msecs.
static bool timeOut(uint32_t to)
Checks whether or not the timeout has expired.
Manages the global system error.
This structure provides information about formatting and parsing.
bool bpsReadSensorAverageV3(BpsRdSensAverageAnswV3 *stat)
return all sensors' mean values
#define E_BPS_NOSOF
no EOF received when expected
#define E_BPS_CHKERR
bad checksum received
bool bfRead(ByteFifo *const bf, uint8_t *const b)
Reads a byte from the byte-fifo.
#define E_BPS_NOEOF
no EOF received when expected
bool errSet(uint32_t code, const char *error, const char *name)
Sets an error.
#define ERROR(CODE,...)
Expands an error code to an error code with a description (if ERROR_W_DESCR is declared).
bool suartTx(SUART_Descriptor *desc, char c)
Transmits a character.
bool bpsReadSensorV3(BpsRdSensAnswV3 *stat)
return all sensors' values
bool bpsAlarmEnV3(uint8_t ch, uint8_t val, BpsAlarmV3 *AlarmEn_rd)
Return current enable status.
This module implements parsing and formating of strings and integers.
bool bpsReadSensorSingleV3(uint8_t single_var, BpsRdSingleAnswV3 *stat)
return one sensor's current value, offset, max, mean value