MBee Arduino library
SerialStar.cpp
1 /* "Системы модули и компоненты" ("СМК"). 2020. Москва.
2 Библиотека MBee-Arduino.
3 Распространяется свободно. Надеемся, что программные продукты, созданные
4 с помощью данной библиотеки будут полезными, однако никакие гарантии, явные или
5 подразумеваемые не предоставляются.
6 
7 The MIT License(MIT)
8 
9 MBee-Arduino Library.
10 Copyright © 2020 Systems, modules and components. Moscow. Russia.
11 
12 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
13 documentation files(the "Software"), to deal in the Software without restriction, including without limitation
14 the rights to use, copy, modify, merge, publish, distribute, sublicense, and / or sell copies of the Software,
15 and to permit persons to whom the Software is furnished to do so, subject to the following conditions :
16 The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
17 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
18 WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE AUTHORS OR
19 COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
20 ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 
22 Code adapted from XBee-Arduino library XBee.h. Copyright info below.
23 * @file XBee.h
24 * @author Andrew Rapp
25 * @license This project is released under the GNU License
26 * @copyright Copyright (c) 2009 Andrew Rapp. All rights reserved
27 * @date 2009
28 * @brief Interface to the wireless XBee modules
29 */
30 
31 #include "MBee.h"
32 
33 /*********************************************************************
34  * Public методы класса MBeeResponse.
35  *********************************************************************/
37 {
38 
39 }
40 
42 {
43  return _apiId;
44 }
45 
46 void MBeeResponse::setApiId(uint8_t apiId)
47 {
48  _apiId = apiId;
49 }
50 
52 {
53  return _msbLength;
54 }
55 
56 void MBeeResponse::setMsbLength(uint8_t msbLength)
57 {
58  _msbLength = msbLength;
59 }
60 
62 {
63  return _lsbLength;
64 }
65 
66 void MBeeResponse::setLsbLength(uint8_t lsbLength)
67 {
68  _lsbLength = lsbLength;
69 }
70 
72 {
73  return _checksum;
74 }
75 
76 void MBeeResponse::setChecksum(uint8_t checksum)
77 {
78  _checksum = checksum;
79 }
80 
82 {
83  return _frameLength;
84 }
85 
86 void MBeeResponse::setFrameLength(uint8_t frameLength)
87 {
88  _frameLength = frameLength;
89 }
90 
91 void MBeeResponse::setFrameData(uint8_t* frameDataPtr)
92 {
93  _frameDataPtr = frameDataPtr;
94 }
95 
97 {
98  return _frameDataPtr;
99 }
100 
102 {
103  return ((_msbLength << 8) & 0xff) + (_lsbLength & 0xff);
104 }
105 
107 {
108  _extendedFieldsLength = length;
109 }
110 
112 {
113  return _extendedFieldsLength;
114 }
115 
117 {
118  init();
119  _apiId = 0;
120  _msbLength = 0;
121  _lsbLength = 0;
122  _frameLength = 0;
123  _extendedFieldsLength = 0;
124 }
125 
127 {
128  _complete = false;
129  _errorCode = NO_ERROR_IN_FRAME;
130  _checksum = 0;
131 }
132 
134 {
135  TxStatusResponse* txStatus = static_cast<TxStatusResponse*>(&txResponse);
136  txStatus->setFrameData(getFrameData());
137  setCommon(txResponse);
138 }
139 
141 {
142  RxResponse* rx = static_cast<RxResponse*>(&rxResponse);
143  rx->setFrameData(getFrameData());
144  setCommon(rxResponse);
145 }
146 
148 {
149  RxIoSampleResponse* io = static_cast<RxIoSampleResponse*>(&ioSample);
150  io->setFrameData(getFrameData());
151  setCommon(ioSample);
152 }
153 
155 {
156  ModemStatusResponse* modem = static_cast<ModemStatusResponse*>(&modemStatusResponse);
157  modem->setFrameData(getFrameData());
158  setCommon(modemStatusResponse);
159 }
160 
162 {
163  AtCommandResponse* at = static_cast<AtCommandResponse*>(&atCommandResponse);
164  at->setFrameData(getFrameData());
165  setCommon(atCommandResponse);
166 }
167 
169 {
170  RemoteAtCommandResponse* at = static_cast<RemoteAtCommandResponse*>(&response);
171  at->setFrameData(getFrameData());
172  setCommon(response);
173 }
174 
176 {
177  RxAcknowledgeResponse* ack = static_cast<RxAcknowledgeResponse*>(&acknowledge);
178  ack->setFrameData(getFrameData());
179  setCommon(acknowledge);
180 }
181 
183 {
184  return _complete;
185 }
186 
187 void MBeeResponse::setAvailable(bool complete)
188 {
189  _complete = complete;
190 }
191 
193 {
194  return _errorCode > 0;
195 }
196 
198 {
199  return _errorCode;
200 }
201 
202 void MBeeResponse::setErrorCode(uint8_t errorCode)
203 {
204  _errorCode = errorCode;
205 }
206 
207 /*********************************************************************
208  * Private методы класса MBeeResponse.
209  *********************************************************************/
210 //Копирование общих полей из принятого сообщения.
211 void MBeeResponse::setCommon(MBeeResponse &target)
212 {
213  target.setApiId(getApiId());
214  target.setAvailable(isAvailable());
215  target.setChecksum(getChecksum());
216  target.setErrorCode(getErrorCode());
218  target.setMsbLength(getMsbLength());
219  target.setLsbLength(getLsbLength());
220  target.setExtendedFieldsLength(0);
221  if((getApiId() == RECEIVE_PACKET_EXTENDED_API_FRAME) ||\
222  (getApiId() == RECEIVE_PACKET_NO_OPTIONS_EXTENDED_API_FRAME) ||\
223  (getApiId() == REMOTE_AT_COMMAND_RESPONSE_EXTENDED_API_FRAME) ||\
224  (getApiId() == IO_DATA_SAMPLE_EXTENDED_API_FRAME))
225 
226 {
227  target.setExtendedFieldsLength(3);
228 }
229 }
230 
231 /*********************************************************************
232  * Public методы класса FrameIdResponse.
233  *********************************************************************/
235 {
236 
237 }
238 
240 {
241  return getFrameData()[0];
242 }
243 
244 /*********************************************************************
245  * Public методы класса ModemStatusResponse.
246  *********************************************************************/
248 {
249 
250 }
251 
253 {
254  return getFrameData()[0];
255 }
256 
257 /*********************************************************************
258  * Public методы класса RxCommonResponse.
259  *********************************************************************/
261 {
262 
263 }
264 
266 {
267  return(getFrameData()[0] << 8) + getFrameData()[1];
268 }
269 
271 {
272  return getFrameData()[2];
273 }
274 
276 {
277  return getFrameData()[3];
278 }
279 
281 {
283  {
284  return getFrameData()[4];
285  }
286  return 0;
287 }
288 
290 {
292  {
293  return(getFrameData()[5] << 8) + getFrameData()[6];
294  }
295  return 0;
296 }
297 
298 /*********************************************************************
299  * Public методы класса AtCommandResponse.
300  *********************************************************************/
302 {
303 
304 }
305 
307 {
308  return getFrameData() + 1;
309 }
310 
312 {
313  return getFrameData()[3];
314 }
315 
317 {
318  return getFrameDataLength() - 4;
319 }
320 
322 {
323  if(getValueLength() > 0)
324  {
325  return getFrameData() + 4; //Поле параметра включается только для команд запроса. Команды устанвоки не имеют в ответе поля параметра.
326  }
327  return NULL;
328 }
329 
331 {
332  return getStatus() == OK_COMMAND_STATUS;
333 }
334 
335 /*********************************************************************
336  * Public методы класса TxStatusResponse.
337  *********************************************************************/
339 {
340 
341 }
342 
344 {
345  return getFrameData()[4];
346 }
347 
349 {
350  return getStatus() == SUCCESS;
351 }
352 
353 /*********************************************************************
354  * Public методы класса RemoteAtCommandResponse.
355  *********************************************************************/
357 {
358 
359 }
360 
362 {
363  return getFrameData() + 4 + getExtendedFieldsLength();
364 }
365 
367 {
368  return getFrameData()[6 + getExtendedFieldsLength()];
369 }
370 
372 {
373  return getStatus() == OK_COMMAND_STATUS;
374 }
375 
377 {
379 }
380 
382 {
383  if(getValueLength() > 0)
384  {
385  return getFrameData() + 7 + getExtendedFieldsLength();
386  }
387  return NULL;
388 }
389 
390 /*********************************************************************
391  * Public методы класса RxAcknowledgeResponse.
392  *********************************************************************/
394 {
395 
396 }
398 {
399  return getFrameDataLength() - 4;
400 }
401 
402 /*********************************************************************
403  * Public методы класса RxDataResponse.
404  *********************************************************************/
406 {
407 
408 }
409 
410 uint8_t RxDataResponse::getData(uint8_t index)
411 {
412  return getFrameData()[getDataOffset() + index];
413 }
414 
416 {
417  return getFrameData() + getDataOffset();
418 }
419 
421 {
422  return (getOption() & BV(PACKET_WAS_BROADCAST_BIT));
423 }
424 
425 /*********************************************************************
426  * Public методы класса RxIoSampleResponse.
427  *********************************************************************/
429 {
430 
431 }
433 {
434  return getPacketLength() - 6 - getExtendedFieldsLength(); //Считаем, что поле данных начинается после полей температуры и напряжения на батарее.
435 }
436 
438 {
439  return 6 + getExtendedFieldsLength();
440 }
441 
443 {
444  uint8_t count = 0;
445  uint8_t i = 1;
446  uint8_t & iRef = i;
447  while(i < getDataLength())
448  {
449  getNextSample(iRef);
450  count++;
451  }
452  return count;
453 }
454 
456 {
457  return getFrameData()[4 + getExtendedFieldsLength()];
458 }
459 
461 {
462  return getFrameData()[5 + getExtendedFieldsLength()];
463 }
464 
465 uint8_t RxIoSampleResponse::getMode(uint8_t number)
466 {
467  return getData()[getSample(number)];
468 }
469 
470 uint8_t RxIoSampleResponse::getPin(uint8_t number)
471 {
472  return getData()[getSample(number) - 1];
473 }
474 
476 {
477  for(uint8_t i = 1; i <= getSampleSize(); i++)
478  {
479  if(getPin(i) == pin)
480  return true;
481  }
482  return false;
483 }
484 
486 {
487  for(uint8_t i = 1; i <= getSampleSize(); i++)
488  {
489  if(getPin(i) == pin)
490  return i;
491  }
492  return 0;
493 }
494 
495 uint16_t RxIoSampleResponse::getAnalog(uint8_t number)
496 {
497  uint16_t analog = (getData()[getSample(number) + 1] << 8) + getData()[getSample(number) + 2];
498  if(analog > 0x7FFF)
499  analog = 0; //Отрицательные числа(старший бит установлен) получаются в результате ошибок округления при коррекции и принимаются равными 0.
500  return analog;
501 }
502 
503 uint8_t RxIoSampleResponse::getDigital(uint8_t number)
504 {
505  if(getData()[getSample(number)] & 0x80) //Информация о текущем состоянии цифрового входа/выхода передается в старшем бите кода режима.
506  return HIGH;
507  else
508  return LOW;
509 }
510 
511 uint32_t RxIoSampleResponse::getCounter(uint8_t number)
512 {
513  return (getData()[getSample(number) + 1] << 24) + (getData()[getSample(number) + 2] << 16) + (getData()[getSample(number) + 3] << 8) + getData()[getSample(number) + 4];
514 }
515 
516 /*********************************************************************
517  * Private методы класса RxIoSampleResponse.
518  *********************************************************************/
519  void RxIoSampleResponse::getNextSample(uint8_t &alias)
520  {
521  switch(getData()[alias] & 0x7F) //Сбрасываем старший бит, в котором передается информация о текущем состоянии цифровой линии.
522  {
523  case IO_ADC:
524  alias += 4;
525  break;
526  case IO_DIGITAL_INPUT:
527  case IO_DIGITAL_OUTPUT_LO:
528  case IO_DIGITAL_OUTPUT_HI:
529  case IO_WAKEUP_INPUT_FALLING_EDGE:
530  case IO_WAKEUP_INPUT_RISING_EDGE:
531  alias += 2;
532  break;
533  case IO_COUNTER_INPUT1:
534  case IO_COUNTER_INPUT2:
535  alias += 6;
536  break;
537  }
538  }
539 
540 uint8_t RxIoSampleResponse::getSample(uint8_t number)
541 {
542  uint8_t count = 1;
543  uint8_t i = 1;
544  uint8_t & iRef = i;
545  while(i < getDataLength())
546  {
547  if(count == number)
548  break;
549  getNextSample(iRef);
550  count++;
551  }
552  return i;
553 }
554 
555 /*********************************************************************
556  * Public методы класса RxResponse.
557  *********************************************************************/
559 {
560 
561 }
562 
564 {
566 }
567 
569 {
570  return 4 + getExtendedFieldsLength();
571 }
572 
574 {
575  return(getOption() & BV(PACKET_ACKNOWLEDGED_BIT));
576 }
577 
578 /*********************************************************************
579  * Public методы класса MBeeRequest.
580  *********************************************************************/
581  MBeeRequest::MBeeRequest(uint8_t apiId, uint8_t frameId)
582  {
583  _apiId = apiId;
584  _frameId = frameId;
585 }
586 
587 void MBeeRequest::setFrameId(uint8_t frameId)
588 {
589  _frameId = frameId;
590 }
591 
593 {
594  return _frameId;
595 }
596 
598 {
599  return _apiId;
600 }
601 
602 void MBeeRequest::setApiId(uint8_t apiId)
603 {
604  _apiId = apiId;
605 }
606 
607 /*********************************************************************
608  * Public методы класса AtCommandRequest.
609  *********************************************************************/
610 AtCommandRequest::AtCommandRequest() : MBeeRequest(AT_COMMAND_API_FRAME, DEFAULT_FRAME_ID)
611 {
612  _command = NULL;
614 }
615 
616 AtCommandRequest::AtCommandRequest(uint8_t *command) : MBeeRequest(AT_COMMAND_API_FRAME, DEFAULT_FRAME_ID)
617 {
618  _command = command;
620 }
621 
622 AtCommandRequest::AtCommandRequest(uint8_t *command, uint8_t *commandValue, uint8_t commandValueLength) : MBeeRequest(AT_COMMAND_API_FRAME, DEFAULT_FRAME_ID)
623 {
624  _command = command;
625  _commandValue = commandValue;
626  _commandValueLength = commandValueLength;
627 }
628 
629 AtCommandRequest::AtCommandRequest(uint8_t *command, uint8_t *commandValue, uint8_t commandValueLength, uint8_t frameId) : MBeeRequest(AT_COMMAND_API_FRAME, frameId)
630 {
631  _command = command;
632  _commandValue = commandValue;
633  _commandValueLength = commandValueLength;
634 }
635 
637 {
638  return _command;
639 }
640 
642 {
643  return _commandValue;
644 }
645 
647 {
648  return _commandValueLength;
649 }
650 
651 void AtCommandRequest::setCommand(uint8_t* command)
652 {
653  _command = command;
654 }
655 
657 {
658  _commandValue = value;
659 }
660 
662 {
663  _commandValueLength = length;
664 }
665 
666 uint8_t AtCommandRequest::getFrameData(uint8_t pos)
667 {
668  if(pos == 0)
669  {
670  return _command[0];
671  }
672  else if(pos == 1)
673  {
674  return _command[1];
675  }
676  else
677  {
678  return _commandValue[pos - AT_COMMAND_API_LENGTH];
679  }
680 }
681 
683 {
684  _commandValue = NULL;
685  _commandValueLength = 0;
686 }
687 
689 {
690  return AT_COMMAND_API_LENGTH + _commandValueLength;
691 }
692 
693 /*********************************************************************
694  * Public методы класса PayloadRequest.
695  *********************************************************************/
696 PayloadRequest::PayloadRequest(uint8_t apiId, uint8_t frameId, uint8_t *payload, uint8_t payloadLength) : MBeeRequest(apiId, frameId)
697 {
698  _payloadPtr = payload;
699  _payloadLength = payloadLength;
700 }
701 
703 {
704  return _payloadPtr;
705 }
706 
707 void PayloadRequest::setPayload(uint8_t* payload)
708 {
709  _payloadPtr = payload;
710 }
711 
713 {
714  return _payloadLength;
715 }
716 
717 void PayloadRequest::setPayloadLength(uint8_t payloadLength)
718 {
719  _payloadLength = payloadLength;
720 }
721 
722 /*********************************************************************
723  * Public методы класса RemoteAtCommandRequest.
724  *********************************************************************/
726 {
727  _remoteAddress = BROADCAST_ADDRESS;
728  _acknowledge = true;
729  _applyChanges = true;
730  _saveChanges = true;
731  _cca = true;
732  _encryption = false;
733  _sleepingDevice = false;
734  setApiId(REMOTE_AT_COMMAND_REQUEST_API_FRAME);
735 }
736 
737 RemoteAtCommandRequest::RemoteAtCommandRequest(uint16_t remoteAddress, uint8_t *command, uint8_t *commandValue, uint8_t commandValueLength) : AtCommandRequest(command, commandValue, commandValueLength)
738 {
739  _remoteAddress = remoteAddress;
740  _acknowledge = true;
741  _applyChanges = true;
742  _saveChanges = true;
743  _cca = true;
744  _encryption = false;
745  _sleepingDevice = false;
746  setApiId(REMOTE_AT_COMMAND_REQUEST_API_FRAME);
747 }
748 
749 RemoteAtCommandRequest::RemoteAtCommandRequest(uint16_t remoteAddress, uint8_t *command) : AtCommandRequest(command, NULL, 0)
750 {
751  _remoteAddress = remoteAddress;
752  _acknowledge = true;
753  _applyChanges = true;
754  _saveChanges = true;
755  _cca = true;
756  _encryption = false;
757  _sleepingDevice = false;
758  setApiId(REMOTE_AT_COMMAND_REQUEST_API_FRAME);
759 }
760 
761 uint16_t RemoteAtCommandRequest::getRemoteAddress()
762 {
763  return _remoteAddress;
764 }
765 
766 void RemoteAtCommandRequest::setRemoteAddress(uint16_t remoteAddress)
767 {
768  _remoteAddress = remoteAddress;
769 }
770 
771 bool RemoteAtCommandRequest::getAcknowledge()
772 {
773  return _acknowledge;
774 }
775 
776 void RemoteAtCommandRequest::setAcknowledge(bool acknowledge)
777 {
778  _acknowledge = acknowledge;
779 }
780 
781 bool RemoteAtCommandRequest::getApplyChanges()
782 {
783  return _applyChanges;
784 }
785 
786 void RemoteAtCommandRequest::setApplyChanges(bool applyChanges)
787 {
788  _applyChanges = applyChanges;
789 }
790 
791 bool RemoteAtCommandRequest::getSaveChanges()
792 {
793  return _saveChanges;
794 }
795 
796 void RemoteAtCommandRequest::setSaveChanges(bool saveChanges)
797 {
798  _saveChanges = saveChanges;
799 }
800 
801 bool RemoteAtCommandRequest::getCca()
802 {
803  return _cca;
804 }
805 
806 void RemoteAtCommandRequest::setCca(bool cca)
807 {
808  _cca = cca;
809 }
810 
811 bool RemoteAtCommandRequest::getEncryption()
812 {
813  return _encryption;
814 }
815 
816 void RemoteAtCommandRequest::setEncryption(bool encryption)
817 {
818  _encryption = encryption;
819 }
820 
821 bool RemoteAtCommandRequest::getSleepingDevice()
822 {
823  return _sleepingDevice;
824 }
825 
826 void RemoteAtCommandRequest::setSleepingDevice(bool sleepingDevice)
827 {
828  _sleepingDevice = sleepingDevice;
829 }
830 
832 {
833  if(pos == 0)
834  {
835  return (_remoteAddress >> 8) & 0xff;
836  }
837  else if(pos == 1)
838  {
839  return _remoteAddress & 0xff;
840  }
841  else if(pos == 2)
842  {
843  return ((_acknowledge ? 0: BV(ACKNOWLEDGE_DISABLE_COMMAND_OPTIONS_BIT)) +\
844  (_applyChanges ? BV(APPLY_CHANGES_COMMAND_OPTION_BIT): 0) +\
845  (_saveChanges ? 0: BV(APPLY_CHANGES_NO_SAVE_COMMAND_OPTION_BIT)) +\
846  (_cca ? 0: BV(CCA_DISABLE_COMMAND_OPTION_BIT)) +\
847  (_encryption ? BV(ENCRYPTION_ENABLE_COMMAND_OPTION_BIT): 0) +\
848  (_sleepingDevice ? BV(SLEEP_DEVICE_COMMAND_OPTIONS_BIT): 0));
849  }
850  else if(pos == 3)
851  {
852  return getCommand()[0];
853  }
854  else if (pos == 4)
855  {
856  return getCommand()[1];
857  }
858  else
859  {
860  return getCommandValue()[pos - REMOTE_AT_COMMAND_API_LENGTH];
861  }
862 }
863 
865 {
866  return REMOTE_AT_COMMAND_API_LENGTH + getCommandValueLength();
867 }
868 
869 void RemoteAtCommandRequest::setDefault()
870 {
871  _remoteAddress = BROADCAST_ADDRESS;
872  _acknowledge = true;
873  _applyChanges = true;
874  _saveChanges = true;
875  _cca = true;
876  _encryption = false;
877  _sleepingDevice = false;
879 }
880 
881 /*********************************************************************
882  * Public методы класса TxRequest.
883  *********************************************************************/
884 TxRequest::TxRequest() : PayloadRequest(TRANSMIT_REQUEST_API_FRAME, DEFAULT_FRAME_ID, NULL, 0)
885 {
886  _remoteAddress = BROADCAST_ADDRESS;
887  _option = TRANSMIT_OPTION_DEFAULT;
888  _optionEnable = true;
889 }
890 
891 TxRequest::TxRequest(uint16_t remoteAddress, uint8_t *data, uint8_t dataLength) : PayloadRequest(TRANSMIT_REQUEST_API_FRAME, DEFAULT_FRAME_ID, data, dataLength)
892 {
893  _remoteAddress = remoteAddress;
894  _optionEnable = true;
895  _option = TRANSMIT_OPTION_DEFAULT;
896 }
897 
898 TxRequest::TxRequest(uint16_t remoteAddress, uint8_t option, uint8_t *data, uint8_t dataLength, uint8_t frameId) : PayloadRequest(TRANSMIT_REQUEST_API_FRAME, frameId, data, dataLength)
899 {
900  _remoteAddress = remoteAddress;
901  _optionEnable = true;
902  _option = option;
903 }
904 
906 {
907  return _remoteAddress;
908 }
909 
910 void TxRequest::setRemoteAddress(uint16_t remoteAddress)
911 {
912  _remoteAddress = remoteAddress;
913 }
914 
916 {
917  return _option;
918 }
919 
920 void TxRequest::setOption(uint8_t option)
921 {
922  _option = option;
923 }
924 
926 {
927  return _optionEnable;
928 }
929 
930 void TxRequest::setOptionEnable(bool optionEnable)
931 {
932  _optionEnable = optionEnable;
933  if(optionEnable)
934  setApiId(TRANSMIT_REQUEST_API_FRAME);
935  else
936  setApiId(TRANSMIT_REQUEST_NO_OPTIONS_API_FRAME);
937 }
938 
940 {
941  return (_option & BV(ACKNOWLEDGE_DISABLE_COMMAND_OPTIONS_BIT)) ? false : true;
942 }
943 
944 void TxRequest::setAcknowledge(bool acknowledge)
945 {
946  if(acknowledge)
947  _option &= ~BV(ACKNOWLEDGE_DISABLE_COMMAND_OPTIONS_BIT);
948  else
949  _option |= BV(ACKNOWLEDGE_DISABLE_COMMAND_OPTIONS_BIT);
950 }
951 
953 {
954  return (_option & BV(CCA_DISABLE_COMMAND_OPTION_BIT)) ? false : true;
955 }
956 
957 void TxRequest::setCca(bool cca)
958 {
959  if(cca)
960  _option &= ~BV(CCA_DISABLE_COMMAND_OPTION_BIT);
961  else
962  _option |= BV(CCA_DISABLE_COMMAND_OPTION_BIT);
963 }
964 
966 {
967  return (_option & BV(ENCRYPTION_ENABLE_COMMAND_OPTION_BIT)) ? true : false;
968 }
969 
970 void TxRequest::setEncryption(bool encryption)
971 {
972  if(encryption)
973  _option |= BV(ENCRYPTION_ENABLE_COMMAND_OPTION_BIT);
974  else
975  _option &= ~BV(ENCRYPTION_ENABLE_COMMAND_OPTION_BIT);
976 }
977 
979 {
980  return (_option & BV(SLEEP_DEVICE_COMMAND_OPTIONS_BIT)) ? true : false;
981 }
982 
983 void TxRequest::setSleepingDevice(bool sleepingDevice)
984 {
985  if(sleepingDevice)
986  _option |= BV(SLEEP_DEVICE_COMMAND_OPTIONS_BIT);
987  else
988  _option &= ~BV(SLEEP_DEVICE_COMMAND_OPTIONS_BIT);
989 }
990 
991 uint8_t TxRequest::getFrameData(uint8_t pos)
992 {
993  if(pos == 0)
994  {
995  return (_remoteAddress >> 8) & 0xFF;
996  }
997  else if(pos == 1)
998  {
999  return _remoteAddress & 0xFF;
1000  }
1001  else if((pos == 2) && _optionEnable)
1002  {
1003  return _option;
1004  }
1005  else
1006  {
1007  if(_optionEnable)
1008  return getPayload()[pos - 3];
1009  else
1010  return getPayload()[pos - 2];
1011  }
1012 }
1013 
1015 {
1016  if(_optionEnable)
1017  return getPayloadLength() + 3;// Добавляется 2 байта адреса + 1 байт опций.
1018  else
1019  return getPayloadLength() + 2;// Добавляется только 2 байта адреса.
1020 }
1021 
1022 /*********************************************************************
1023  * Public методы класса SerialStar.
1024  *********************************************************************/
1025  SerialStar::SerialStar(): _response(MBeeResponse())
1026  {
1027  _pos = 0;
1028  _escape = false;
1029  _checksumTotal = 0;
1030  _nextFrameId = 0;
1031 
1032  _response.init();
1033  _response.setFrameData(_responseFrameData);
1034 #if defined(__AVR_ATmega32U4__) || (defined(TEENSYDUINO) && (defined(KINETISK) || defined(KINETISL)))
1035  _serial = &Serial1;
1036 #else
1037  _serial = &Serial;
1038 #endif
1039 }
1040 
1041 /*********************************************************************
1042  * Переопределенные Public методы класса SerialStar, наследуемые из MBee868
1043  *********************************************************************/
1045 {
1046  if(_response.isAvailable() || _response.isError())
1047  resetResponse(); //Сброс предыдущих сообщений.
1048  while(available())
1049  {
1050  b = read();
1051  if(_pos > 0 && b == START_BYTE && ATAP == 2)
1052  {
1053  //Обнаружен стартовый байт до окончания обработки предыдущего пакета. Сбрасываем предыдущее сообщение и начинаем разбор заново.
1054  _response.setErrorCode(UNEXPECTED_START_BYTE);
1055  return;
1056  }
1057  if(_pos > 0 && b == ESCAPE)
1058  {
1059  if(available())
1060  {
1061  b = read();
1062  b = 0x20 ^ b; //Извлекаем символ из escape-последовательности.
1063  }
1064  else
1065  {
1066  _escape = true; //Ставим флаг того, что следующий байт будет являться вторым символом из escape-последовательности.
1067  continue;
1068  }
1069  }
1070  if(_escape == true)
1071  {
1072  b = 0x20 ^ b;
1073  _escape = false; //Предыдущий байт был escape-символом. Извлекаем символ из escape-последовательности.
1074  }
1075  if(_pos >= API_ID_INDEX) //Контрольную сумму считаем начиная с байта типа API-фрейма.
1076  _checksumTotal+= b;
1077 
1078  //Конечный автомат парсера.
1079  switch(_pos)
1080  {
1081  case 0:
1082  if(b == START_BYTE)
1083  _pos++;
1084  break;
1085  case 1:
1086  _response.setMsbLength(b);
1087  _pos++;
1088  break;
1089  case 2:
1090  _response.setLsbLength(b);
1091  _pos++;
1092  break;
1093  case 3:
1094  _response.setApiId(b);
1095  _pos++;
1096  break;
1097  default:
1098  //Далее разбираются байты, следующие за 4-ым.
1099  if(_pos > MAX_FRAME_DATA_SIZE + 4)
1100  {
1101  _response.setErrorCode(PACKET_EXCEEDS_BYTE_ARRAY_LENGTH); //Длина пакета превышает максимально допустимую.
1102  return;
1103  }
1104  //Проверяем, не достигли ли еще конца поля данных.
1105  if(_pos == (_response.getPacketLength() + 3))
1106  {
1107  if((_checksumTotal & 0xff) == 0xff)
1108  {
1109  _response.setChecksum(b);
1110  _response.setAvailable(true);
1111  _response.setErrorCode(NO_ERROR_IN_FRAME);
1112  }
1113  else
1114  _response.setErrorCode(CHECKSUM_FAILURE); //Ошибка контрольной суммы.
1115  _response.setFrameLength(_pos - 4); //Длина поля данных не включает также поле Frame Type.
1116  _pos = 0;
1117  return;
1118  }
1119  else
1120  {
1121  _response.getFrameData()[_pos - 4] = b; //Добавляем считанный символ в поле данных.
1122  _pos++;
1123  }
1124  }
1125  }
1126 }
1127 
1128 bool SerialStar::readPacket(int timeout)
1129 {
1130  if(timeout < 0)
1131  {
1132  return false;
1133  }
1134  unsigned long start = millis();
1135  while(int((millis() - start)) < timeout)
1136  {
1137  readPacket();
1138  if(getResponse().isAvailable())
1139  {
1140  return true;
1141  }
1142  else if(getResponse().isError())
1143  {
1144  return false;
1145  }
1146  }
1147  return false; //Таймаут..
1148 }
1149 
1151 {
1152  while(!(getResponse().isAvailable() || getResponse().isError()))
1153  {
1154  readPacket();
1155  }
1156 }
1157 
1158 void SerialStar::send(void* buffer)
1159 {
1160  send((MBeeRequest&) buffer);
1161 }
1162 
1163 void SerialStar::send(MBeeRequest & request)
1164 {
1165  sendByte(START_BYTE, false);
1166  uint8_t msbLen = ((request.getFrameDataLength() + 2) >> 8) & 0xFF;
1167  uint8_t lsbLen = (request.getFrameDataLength() + 2) & 0xFF;
1168 
1169  sendByte(msbLen, true);
1170  sendByte(lsbLen, true);
1171 
1172  sendByte(request.getApiId(), true);
1173  sendByte(request.getFrameId(), true);
1174 
1175  uint8_t checksum = 0;
1176 
1177  checksum+= request.getApiId();
1178  checksum+= request.getFrameId();
1179 
1180  for(int i = 0; i < request.getFrameDataLength(); i++)
1181  {
1182  sendByte(request.getFrameData(i), true);
1183  checksum+= request.getFrameData(i);
1184  }
1185 
1186  checksum = 0xff - checksum;
1187  sendByte(checksum, true);
1188 }
1189 
1190 MBeeResponse& SerialStar::getResponse()
1191 {
1192  return _response;
1193 }
1194 
1195 /*********************************************************************
1196  * Private методы класса SerialStar.
1197  *********************************************************************/
1198  void SerialStar::sendByte(uint8_t b, bool escape)
1199  {
1200  // if(escape && (b == START_BYTE || b == ESCAPE || b == XON || b == XOFF))
1201  // {
1202  // write(ESCAPE);
1203  // write(b ^ 0x20);
1204  // }
1205  // else
1206  // {
1207  // write(b);
1208  // }
1209  write(b); //Проект SerialStar не поддерживает пакетный режим с escape-символами в направлении хост->модуль.
1210 }
1211  void SerialStar::resetResponse()
1212  {
1213  _pos = 0;
1214  _escape = false;
1215  _checksumTotal = 0;
1216  _response.reset();
1217 }
1218 
1219 /*********************************************************************
1220  * Public методы класса SerialStarWithCallbacks.
1221  *********************************************************************/
1223  {
1224  if(loopTop())
1225  loopBottom();
1226 }
1227 
1229 {
1230  uint8_t status;
1231  unsigned long start = millis();
1232  send(request);
1233  status = waitForStatus(request.getFrameId(), timeout - (millis() - start));
1234  if(status)
1235  return status;
1236  return waitForAcknowledge(request.getFrameId(), timeout - (millis() - start));
1237 }
1238 
1239 uint8_t SerialStarWithCallbacks::waitForStatus(uint8_t frameId, uint16_t timeout)
1240 {
1241  unsigned long start = millis();
1242  do
1243  {
1244  if(loopTop())
1245  {
1246  uint8_t status = matchStatus(frameId);
1247  if(status != 0xff)
1248  return status;
1249  loopBottom(); //Вызываем регулярные callback-функции.
1250  }
1251  } while (millis() - start < timeout);
1252  return MBEE_WAIT_TIMEOUT ;
1253 }
1254 
1255 uint8_t SerialStarWithCallbacks::waitForAcknowledge(uint8_t frameId, uint16_t timeout)
1256 {
1257  unsigned long start = millis();
1258  do
1259  {
1260  if(loopTop())
1261  {
1262  uint8_t status = matchAcknowledge(frameId);
1263  if(!status)
1264  return 0;
1265  loopBottom(); //Вызываем регулярные callback-функции.
1266  }
1267  } while (millis() - start < timeout);
1268  return MBEE_WAIT_TIMEOUT ;
1269 }
1270 
1271  /*********************************************************************
1272  * Private методы класса SerialStarWithCallbacks.
1273  *********************************************************************/
1274 uint8_t SerialStarWithCallbacks::waitForInternal(uint8_t apiId, void *response, uint16_t timeout, void *func, uintptr_t data, int16_t frameId)
1275 {
1276  unsigned long start = millis();
1277  do
1278  {
1279  if(loopTop()) //Ждем API-фрейм заданного типа.
1280  {
1281  if(frameId >= 0)
1282  {
1283  uint8_t status = matchStatus(frameId);
1284  if(status != 0xff && status != 0) //Если был принят фрейм со статусом и этот статус говорит о произошедшей ошибке, то прекращаем ожидание.
1285  return status;
1286  }
1287  if(getResponse().getApiId() == apiId)
1288  {
1289  //Если принят API-фрейм требуемого типа, то вызываем соответствующую apiId функцию преобразования типа принятого фрейма и затем функцию обработки.
1290  //Так как функции обработки вызываются одним и тем же способом, независимо от обрабатываемого подкласса (типа API-фрейма), то компилятор может
1291  //сократить всю эту кучу кода, находящуюся ниже в единственный блок. Хотя, для полной оптимизации, отдельные методы getXxxResponse() должны быть
1292  //унифицированы подобным образом.
1293  switch(apiId)
1294  {
1295  case MODEM_STATUS_API_FRAME:
1296  {
1297  ModemStatusResponse *r = (ModemStatusResponse*)response;
1298  bool(*f)(ModemStatusResponse&,uintptr_t) = (bool(*)(ModemStatusResponse&,uintptr_t))func;
1299  getResponse().getModemStatusResponse(*r);
1300  if(!f || f(*r, data))
1301  return 0;
1302  break;
1303  }
1304 
1305  case TRANSMIT_STATUS_API_FRAME:
1306  {
1307  TxStatusResponse *r = (TxStatusResponse*)response;
1308  bool(*f)(TxStatusResponse&,uintptr_t) = (bool(*)(TxStatusResponse&,uintptr_t))func;
1309  getResponse().getTxStatusResponse(*r);
1310  if(!f || f(*r, data))
1311  return 0;
1312  break;
1313  }
1314 
1315  case AT_COMMAND_RESPONSE_IMMEDIATE_APPLY_API_FRAME:
1316  case AT_COMMAND_RESPONSE_API_FRAME:
1317  case AT_COMMAND_RESPONSE_QUEUE_PARAMETER_VALUE_API_FRAME:
1318  {
1319  AtCommandResponse *r = (AtCommandResponse*)response;
1320  bool(*f)(AtCommandResponse&,uintptr_t) = (bool(*)(AtCommandResponse&,uintptr_t))func;
1321  getResponse().getAtCommandResponse(*r);
1322  if(!f || f(*r, data))
1323  return 0;
1324  break;
1325  }
1326 
1327  case REMOTE_AT_COMMAND_RESPONSE_API_FRAME:
1328  case REMOTE_AT_COMMAND_RESPONSE_EXTENDED_API_FRAME:
1329  {
1331  bool(*f)(RemoteAtCommandResponse&,uintptr_t) = (bool(*)(RemoteAtCommandResponse&,uintptr_t))func;
1332  getResponse().getRemoteAtCommandResponse(*r);
1333  if(!f || f(*r, data))
1334  return 0;
1335  break;
1336  }
1337 
1338  case REMOTE_ACKNOWLEDGE_API_FRAME:
1339  {
1341  bool(*f)(RxAcknowledgeResponse&,uintptr_t) = (bool(*)(RxAcknowledgeResponse&,uintptr_t))func;
1342  getResponse().getRxAcknowledgeResponse(*r);
1343  if(!f || f(*r, data))
1344  return 0;
1345  break;
1346  }
1347 
1348  case RECEIVE_PACKET_API_FRAME:
1349  case RECEIVE_PACKET_EXTENDED_API_FRAME:
1350  case RECEIVE_PACKET_NO_OPTIONS_API_FRAME:
1351  case RECEIVE_PACKET_NO_OPTIONS_EXTENDED_API_FRAME:
1352  {
1353  RxResponse *r = (RxResponse*)response;
1354  bool(*f)(RxResponse&,uintptr_t) = (bool(*)(RxResponse&,uintptr_t))func;
1355  getResponse().getRxResponse(*r);
1356  if(!f || f(*r, data))
1357  return 0;
1358  break;
1359  }
1360 
1361  case IO_DATA_SAMPLE_API_FRAME:
1362  case IO_DATA_SAMPLE_EXTENDED_API_FRAME:
1363  {
1364  RxResponse *r = (RxResponse*)response;
1365  bool(*f)(RxResponse&,uintptr_t) = (bool(*)(RxResponse&,uintptr_t))func;
1366  getResponse().getRxResponse(*r);
1367  if(!f || f(*r, data))
1368  return 0;
1369  break;
1370  }
1371  }
1372  }
1373  loopBottom();
1374  }
1375  } while (millis() - start < timeout);
1376  return MBEE_WAIT_TIMEOUT;
1377 }
1378 
1379 uint8_t SerialStarWithCallbacks::matchStatus(uint8_t frameId)
1380 {
1381  uint8_t id = getResponse().getApiId();
1382  uint8_t *data = getResponse().getFrameData();
1383  uint8_t len = getResponse().getFrameDataLength();
1384  uint8_t offset = 0;
1385 
1386  //Если фрейм имеет поле frameId, то определяем с каким смещением расположен в нем байт статуса.
1387  if((id == AT_COMMAND_RESPONSE_IMMEDIATE_APPLY_API_FRAME) || (id == AT_COMMAND_RESPONSE_API_FRAME) || (id == AT_COMMAND_RESPONSE_QUEUE_PARAMETER_VALUE_API_FRAME))
1388  offset = 3;
1389  else if(id == REMOTE_AT_COMMAND_RESPONSE_API_FRAME)
1390  offset = 6;
1391  else if(id == TRANSMIT_STATUS_API_FRAME)
1392  offset = 1;
1393 
1394  //Если фрейм содержит байт статуса (определяется по смещению не равному 0), если длина принятого фрейма больше, чем смещение (фрейм корректен), а также если
1395  //требуемый frameId совпадает с frameId, содержащимся в принятом фрейме, то считываем байт статуса.
1396  if(offset && offset < len && data[0] == frameId)
1397  return data[offset];
1398  return 0xff;
1399 }
1400 
1401 uint8_t SerialStarWithCallbacks::matchAcknowledge(uint8_t frameId)
1402 {
1403  uint8_t id = getResponse().getApiId();
1404  uint8_t *data = getResponse().getFrameData();
1405  if(id == REMOTE_ACKNOWLEDGE_API_FRAME)
1406  {
1407  if(data[4] == frameId) //В 4-б байте передается frameId подтверждаемого пакета.
1408  return 0;
1409  }
1410  return 0xff;
1411 }
1412 
1413 bool SerialStarWithCallbacks::loopTop()
1414 {
1415  readPacket();
1416  if(getResponse().isAvailable())
1417  {
1418  _onResponse.call(getResponse());
1419  return true;
1420  }
1421  else if(getResponse().isError())
1422  {
1423  _onPacketError.call(getResponse().getErrorCode());
1424  }
1425  return false;
1426 }
1427 
1428 void SerialStarWithCallbacks::loopBottom()
1429 {
1430  bool called = false;
1431  uint8_t id = getResponse().getApiId();
1432  if(id == MODEM_STATUS_API_FRAME)
1433  {
1434  ModemStatusResponse response;
1435  getResponse().getModemStatusResponse(response);
1436  called = _onModemStatusResponse.call(response);
1437  }
1438  else if(id == TRANSMIT_STATUS_API_FRAME)
1439  {
1440  TxStatusResponse response;
1441  getResponse().getTxStatusResponse(response);
1442  called = _onTxStatusResponse.call(response);
1443  }
1444  else if((id == AT_COMMAND_RESPONSE_IMMEDIATE_APPLY_API_FRAME) || (id == AT_COMMAND_RESPONSE_API_FRAME) || (id == AT_COMMAND_RESPONSE_QUEUE_PARAMETER_VALUE_API_FRAME))
1445  {
1446  AtCommandResponse response;
1447  getResponse().getAtCommandResponse(response);
1448  called = _onAtCommandResponse.call(response);
1449  }
1450  else if((id == REMOTE_AT_COMMAND_RESPONSE_API_FRAME) || (id == REMOTE_AT_COMMAND_RESPONSE_EXTENDED_API_FRAME))
1451  {
1452  RemoteAtCommandResponse response;
1453  getResponse().getRemoteAtCommandResponse(response);
1454  called = _onRemoteAtCommandResponse.call(response);
1455  }
1456  else if(id == REMOTE_ACKNOWLEDGE_API_FRAME)
1457  {
1458  RxAcknowledgeResponse response;
1459  getResponse().getRxAcknowledgeResponse(response);
1460  called = _onRxAcknowledgeResponse.call(response);
1461  }
1462  else if((id == RECEIVE_PACKET_API_FRAME) || (id == RECEIVE_PACKET_NO_OPTIONS_API_FRAME) || (id == RECEIVE_PACKET_EXTENDED_API_FRAME) || (id == RECEIVE_PACKET_NO_OPTIONS_EXTENDED_API_FRAME))
1463  {
1464  RxResponse response;
1465  getResponse().getRxResponse(response);
1466  called = _onRxResponse.call(response);
1467  }
1468  else if((id == IO_DATA_SAMPLE_API_FRAME) || (id == IO_DATA_SAMPLE_EXTENDED_API_FRAME))
1469  {
1470  RxIoSampleResponse response;
1471  getResponse().getRxIoSampleResponse(response);
1472  called = _onRxIoSampleResponse.call(response);
1473  }
1474 
1475  if (!called)
1476  _onOtherResponse.call(getResponse());
1477 }
1478 
1479 
1480 
1481 
1482 
RxDataResponse()
Конструктор "по умолчанию".
Definition: SerialStar.cpp:405
uint8_t getCommandValueLength()
Возвращает длину поля параметра команды.
Definition: SerialStar.cpp:646
uint8_t getFrameDataLength()
Возвращает длину командного фрейма команды.
Definition: SerialStar.cpp:864
uint8_t getFrameId()
Возвращает frameId в случае приема пакета расширенного формата.
Definition: SerialStar.cpp:280
Класс расширяет базовый класс MBeeResponse для всех сообщений, которые имеют поле frame id...
Definition: SerialStar.h:366
Супер класс для всех пакетов, передаваемых от хоста к модулям MBee-868-x.0 в проекте SerialStar...
Definition: SerialStar.h:705
Класс для локального ответа модуля со статусом передачи в эфир или размещением в буфере.
Definition: SerialStar.h:476
uint8_t getFrameId()
Возвращает frame id.
Definition: SerialStar.cpp:592
bool isOk()
Возвращает true, если команда успешно выполнена удаленным модулем.
Definition: SerialStar.cpp:371
void setEncryption(bool encryption)
Включает/выключает шифрование поля данных передаваемого пакета.
Definition: SerialStar.cpp:970
uint8_t getLsbLength()
Возвращает LSB длины поля данных.
Definition: SerialStar.cpp:61
uint8_t getFrameId()
Возвращает frameId пакета, полученного удаленным модулем на который отправлено это подтверждение...
Definition: SerialStar.cpp:397
Класс для выдачи в UART принятых по эфиру пакетов, содержаших неструктированные данные.
Definition: SerialStar.h:675
void readPacketUntilAvailable()
Ожидает приема пакета до тех пор, пока он не будет получен или не произойдет какая-либо ошибка...
AtCommandRequest()
Конструктор "по умолчанию".
Definition: SerialStar.cpp:610
void getTxStatusResponse(MBeeResponse &response)
Вызов TxStatusResponse при getApiId() == 0x8B.
Definition: SerialStar.cpp:133
uint8_t getPayloadLength()
Возвращает установленную длину поля данных.
Definition: SerialStar.cpp:712
uint8_t * getPayload()
Возвращает указатель на поле данных.
Definition: SerialStar.cpp:702
uint8_t getValueLength()
Возвращает длину поля параметра команды.
Definition: SerialStar.cpp:376
void setAvailable(bool complete)
Устанавливает признак доступности пакета.
Definition: SerialStar.cpp:187
void setFrameId(uint8_t frameId)
Устанавливает frame id.
Definition: SerialStar.cpp:587
void getAtCommandResponse(MBeeResponse &responses)
Вызов AtCommandResponse при getApiId() == x88).
Definition: SerialStar.cpp:161
uint8_t * getCommandValue()
Возвращает указатель на первый байт параметра команды.
Definition: SerialStar.cpp:641
bool isError()
Возвращает true если при разборе пакета произошли ошибки.
Definition: SerialStar.cpp:192
uint8_t getMsbLength()
Возвращает MSB длины поля данных.
Definition: SerialStar.cpp:51
void setCca(bool cca)
Включает/выключает режим CCA (Clear Channel Assessment) при отправке пакетов.
Definition: SerialStar.cpp:957
bool isAddressBroadcast()
Возвращает true, если принятый пакет был широковещательный.
Definition: SerialStar.cpp:420
void setCommandValueLength(uint8_t length)
Устанавливает длину поля параметра команды.
Definition: SerialStar.cpp:661
bool getSleepingDevice()
Возвращает true, если пакет предназначается для спящего модема.
Definition: SerialStar.cpp:978
Класс для ответа на командный API-фрейм для удаленного узла.
Definition: SerialStar.h:504
uint8_t getExtendedFieldsLength(void)
Возвращает длину дополнительных полей пакета расширенного формата.
Definition: SerialStar.cpp:111
RxIoSampleResponse()
Конструктор "по умолчанию".
Definition: SerialStar.cpp:428
uint8_t * getValue()
Возвращает указатель на массив, содержащий параметр команды.
Definition: SerialStar.cpp:321
uint8_t getFrameDataLength()
Возвращает длину данных в пакете между полем типа API-фрейма и контрольной суммой.
Definition: SerialStar.cpp:81
void setErrorCode(uint8_t errorCode)
Устанавливает код ошибки.
Definition: SerialStar.cpp:202
void getRxAcknowledgeResponse(MBeeResponse &response)
Вызов RxAcknowledgeResponse при getApiId() == 0x8C.
Definition: SerialStar.cpp:175
uint8_t * getCommand()
Возвращает указатель на массив, содержащий 2 ASCII символа AT-команды.
Definition: SerialStar.cpp:361
TxRequest()
Конструктор "по умолчанию".
Definition: SerialStar.cpp:884
Супер класс для всех пакетов, передаваемых по UART модулями MBee-868-x.0 в проекте SerialStar...
Definition: SerialStar.h:202
uint16_t getPreviousHopAddress()
Возвращает адрес модема, непосредственно отправившего пакет.
Definition: SerialStar.cpp:289
uint8_t getVbatt()
Возвращает напряжение источника питания удаленного модема.
Definition: SerialStar.cpp:460
uint8_t getApiId()
Возвращает тип API-фрейма.
Definition: SerialStar.cpp:41
void setRemoteAddress(uint16_t remoteAddress)
Устанавливает адрес получателя пакета.
Definition: SerialStar.cpp:910
uint8_t getDigital(uint8_t number)
Возвращает текущее состояние цифрового входа/выхода, соответствующего порядковому номеру выборки в пр...
Definition: SerialStar.cpp:503
void setOptionEnable(bool optionEnable)
Включает/выключает передачу пакетов в соответствии с байтом опций.
Definition: SerialStar.cpp:930
MBeeRequest(uint8_t apiId, uint8_t frameId)
Конструктор, создающий фрейм с заданным API ID и идентификатором.
Definition: SerialStar.cpp:581
bool isAvailable()
Возвращает true, если пакет успешно принят.
Definition: SerialStar.cpp:182
void setApiId(uint8_t apiId)
Устанавливает тип API-фрейма.
Definition: SerialStar.cpp:602
MBeeResponse()
Конструктор "по умолчанию".
Definition: SerialStar.cpp:36
void getModemStatusResponse(MBeeResponse &response)
Вызов ModemStatusResponse при getApiId() == 0x8A.
Definition: SerialStar.cpp:154
uint8_t getFrameDataLength()
Возвращает длину командного фрейма команды.
Definition: SerialStar.cpp:688
uint8_t getStatus()
Возвращает статус команды.
Definition: SerialStar.cpp:311
bool getAcknowledge()
Возвращает true, если подтверждение удаленным модемом получения пакета включено.
Definition: SerialStar.cpp:939
void getRemoteAtCommandResponse(MBeeResponse &response)
Вызов RemoteAtCommandResponse при getApiId() == 0x97, 0x98.
Definition: SerialStar.cpp:168
void setPayload(uint8_t *payloadPtr)
Устанавливает указатель на поле данных.
Definition: SerialStar.cpp:707
RxResponse()
Конструктор "по умолчанию".
Definition: SerialStar.cpp:558
uint32_t getCounter(uint8_t number)
Возвращает число подсчитанных импульсов для счетного входа, соответствующего порядковому номеру выбор...
Definition: SerialStar.cpp:511
virtual uint8_t getDataOffset()=0
Возвращает номер байта в принятом пакете с которого начинается поле данных.
uint8_t getFrameId()
Возвращает идентификатор фрейма.
Definition: SerialStar.cpp:239
void reset()
Сбрасывает все поля пакета.
Definition: SerialStar.cpp:116
void send(void *)
Передача данных модулю или удаленному узлу.
uint8_t getApiId()
Возвращает тип API-фрейма.
Definition: SerialStar.cpp:597
virtual uint8_t getFrameData(uint8_t pos)=0
Возвращает буфер, который содержит сообщение.
Класс для пакета с подтверждением получения неструктурированных данных удаленным модемом.
Definition: SerialStar.h:542
uint8_t waitForStatus(uint8_t frameId, uint16_t timeout)
Ждет приема ответного API-фрейма со статусом после отправки пакета с определенным frameId в течение з...
uint8_t getFrameDataLength()
Возвращает полную длину поля данных API-фрейма.
Класс для локального управления модулем с помощью API-фрейма.
Definition: SerialStar.h:752
uint8_t getSampleSize()
Возвращает число линий ввода/вывода данные о текущем состоянии которых имеются в принятом пакете...
Definition: SerialStar.cpp:442
uint8_t getChecksum()
Подсчет контрольной суммы.
Definition: SerialStar.cpp:71
Класс для API-фрейма со статусом модема после инициализации.
Definition: SerialStar.h:385
uint16_t getPacketLength()
Возвращает длину пакета.
Definition: SerialStar.cpp:101
void readPacket()
Чтение всех байт, имеющихся в приемном буфере UART.
void setChecksum(uint8_t checksum)
Запись контрольной суммы в соответствующее поле пакета.
Definition: SerialStar.cpp:76
uint8_t getMode(uint8_t number)
Возвращает режим линии ввода/ввода по порядковому номеру выборки в принятом пакете.
Definition: SerialStar.cpp:465
void setCommandValue(uint8_t *value)
Устанавливает указатель на первый байт параметра команды.
Definition: SerialStar.cpp:656
uint16_t getRemoteAddress()
Возвращает адрес получателя пакета.
Definition: SerialStar.cpp:905
uint8_t getDataLength()
Возвращает длину поля данных пакета.
Definition: SerialStar.cpp:563
uint8_t waitForAcknowledge(uint8_t frameId, uint16_t timeout)
Ждет API-фрейм c подтверждением приема удаленным модулем пакета с определенным frameId в течение зада...
bool getCca()
Возвращает true, если при отправке пакетов включен режим CCA (Clear Channel Assessment).
Definition: SerialStar.cpp:952
Базовый класс для всех пакетов, принятых по эфиру и передаваемых модулем на UART. ...
Definition: SerialStar.h:402
bool getOptionEnable()
Возвращает true, если передача пакета осуществляется в соответствии с байтом опций и false...
Definition: SerialStar.cpp:925
RemoteAtCommandRequest()
Конструктор "по умолчанию".
Definition: SerialStar.cpp:725
uint8_t getDataLength()
Возвращает длину поля данных, не включая 2 байт с температурой и напряжением источника питания удален...
Definition: SerialStar.cpp:432
uint8_t getTemperature()
Возвращает температуру, измеренную на удаленном модеме.
Definition: SerialStar.cpp:455
uint16_t getRemoteAddress()
Возвращает адрес модема, источника данных.
Definition: SerialStar.cpp:265
uint8_t getFrameData(uint8_t pos)
Возвращает байт поля данных, номер которого определяется аргументом.
Definition: SerialStar.cpp:991
void setAcknowledge(bool acknowledge)
Включает/выключает отправку подтверждения удаленным модемом получения пакета.
Definition: SerialStar.cpp:944
void setSleepingDevice(bool sleepingDevice)
Включает/выключает буферизацию пакетов для спящих модемов.
Definition: SerialStar.cpp:983
void init()
Инициализация пакета.
Definition: SerialStar.cpp:126
uint8_t getDataOffset()
Возвращает смещение поля данных относительно старшего байта адреса.
Definition: SerialStar.cpp:568
uint8_t getRssi()
Возвращает RSSI на антенном входе модуля, зафиксированный в момент приема пакета. ...
Definition: SerialStar.cpp:270
uint8_t * getData()
Возвращает указатель на поле данных принятого пакета.
Definition: SerialStar.cpp:415
ModemStatusResponse()
Конструктор "по умолчанию".
Definition: SerialStar.cpp:247
void run()
Главный цикл.
uint8_t * getCommand()
Возвращает указатель на байты с кодом команды.
Definition: SerialStar.cpp:636
RxCommonResponse()
Конструктор "по умолчанию".
Definition: SerialStar.cpp:260
virtual uint8_t getFrameDataLength()=0
Возвращает длину поля данных фрейма, не включая frame id или api id и checksum.
void setOption(uint8_t option)
Устанавливает опции отправки пакета.
Definition: SerialStar.cpp:920
AtCommandResponse()
Конструктор "по умолчанию".
Definition: SerialStar.cpp:301
Класс для ответа на локальный командный API-фрейм.
Definition: SerialStar.h:439
bool isSuccess()
Возвращает true, если команда исполнена.
Definition: SerialStar.cpp:348
uint8_t getDataOffset()
Возвращает номер байта в принятом пакете с которого начинается поле данных.
Definition: SerialStar.cpp:437
uint8_t getErrorCode()
Возвращает код ошибки или 0, если их нет.
Definition: SerialStar.cpp:197
FrameIdResponse()
Конструктор "по умолчанию".
Definition: SerialStar.cpp:234
TxStatusResponse()
Конструктор "по умолчанию".
Definition: SerialStar.cpp:338
void setPayloadLength(uint8_t payloadLength)
Устанавливает число байт, которое надо поместить в поле данных отправляемого пакета.
Definition: SerialStar.cpp:717
uint8_t getStatus()
Возвращает статус команды.
Definition: SerialStar.cpp:366
uint8_t getStatus()
Возвращает статус локальной команды.
Definition: SerialStar.cpp:343
void getRxResponse(MBeeResponse &response)
Вызов RxResponse при getApiId() == 0x81, 0x82, 0x8F, 0x90.
Definition: SerialStar.cpp:140
void setCommand(uint8_t *command)
Устанавливает команду по указателю на байты на кода.
Definition: SerialStar.cpp:651
RxAcknowledgeResponse()
Конструктор "по умолчанию".
Definition: SerialStar.cpp:393
uint8_t getFrameData(uint8_t pos)
Возвращает в зависимости о номера байта либо код AT-команды, содержащейся в фрейме, либо байта параметра команды.
Definition: SerialStar.cpp:831
uint8_t getValueLength()
Возвращает длину поля параметра команды.
Definition: SerialStar.cpp:316
void getRxIoSampleResponse(MBeeResponse &response)
Вызов RxIoSampleResponse при getApiId() == 0x83, 0x84.
Definition: SerialStar.cpp:147
uint8_t getStatus()
Возвращает статус модема после рестарта.
Definition: SerialStar.cpp:252
Базовый класс для всех пакетов, предназначенных для передачи по эфиру неструктурированных данных...
Definition: SerialStar.h:828
uint8_t * getFrameData()
Возвращает указатель на буфер, который содержит сообщение.
Definition: SerialStar.cpp:96
RemoteAtCommandResponse()
Конструктор "по умолчанию".
Definition: SerialStar.cpp:356
uint8_t getPin(uint8_t number)
Возвращает номер вывода модуля, соответствующий порядковому номеру выборки в принятом пакете...
Definition: SerialStar.cpp:470
uint8_t * getValue()
Возвращает указатель на массив, содержащий параметр команды.
Definition: SerialStar.cpp:381
uint8_t getOption()
Возвращает байт опций.
Definition: SerialStar.cpp:275
bool isOk()
Возвращает true, если статус эквивалентен AT_OK.
Definition: SerialStar.cpp:330
bool getEncryption()
Возвращает true, если включен режим шифрования поля данных.
Definition: SerialStar.cpp:965
void setFrameLength(uint8_t frameLength)
Запись поля длины в пакете.
Definition: SerialStar.cpp:86
Класс для всех пакетов, принятых по эфиру, передаваемых модулем на UART и содержащих поле данных...
Definition: SerialStar.h:560
uint8_t getOption()
Возвращает значение байта опций отправки пакета.
Definition: SerialStar.cpp:915
void clearCommandValue()
Присваивает указателю на поле кода команды значение NULL и обнуляет поле длины параметра команды...
Definition: SerialStar.cpp:682
uint8_t getSampleNumber(uint8_t pin)
Возвращает порядковый номер выборки в принятом пакете, в котором содержится информация о текущем сост...
Definition: SerialStar.cpp:485
uint8_t sendAndWaitForAcknowledge(MBeeRequest &request, uint16_t timeout)
Передает в UART API-фрейм, предназначенный для передачи по эфиру.
bool isAcknowledged()
Возвращает true, если на принятый пакет было отправлено подтверждение.
Definition: SerialStar.cpp:573
uint8_t * getCommand()
Возвращает указатель на массив, содержащий 2 ASCII символа AT-команды.
Definition: SerialStar.cpp:306
void setFrameData(uint8_t *frameDataPtr)
Устанавливает указатель на поле данных пакета.
Definition: SerialStar.cpp:91
uint8_t getFrameData(uint8_t pos)
Возвращает в зависимости о номера байта либо код AT-команды, содержащейся в фрейме, либо байта параметра команды.
Definition: SerialStar.cpp:666
uint16_t getAnalog(uint8_t number)
Возвращает текущее состояние аналогового входа, соответствующего порядковому номеру выборки в принято...
Definition: SerialStar.cpp:495
void setExtendedFieldsLength(uint8_t length)
Устанавливает длину дополнительных полей пакета расширенного формата.
Definition: SerialStar.cpp:106