sbgEComCmdOutput.c
Go to the documentation of this file.
1 #include "sbgEComCmdOutput.h"
2 #include <streamBuffer/sbgStreamBuffer.h>
3 
4 //----------------------------------------------------------------------//
5 //- Output commands -//
6 //----------------------------------------------------------------------//
7 
17 SbgErrorCode sbgEComCmdOutputGetConf(SbgEComHandle *pHandle, SbgEComOutputPort outputPort, SbgEComClass classId, SbgEComMsgId msgId, SbgEComOutputMode *pConf)
18 {
19  SbgErrorCode errorCode = SBG_NO_ERROR;
20  uint32_t trial;
21  size_t receivedSize;
22  uint8_t receivedBuffer[SBG_ECOM_MAX_BUFFER_SIZE];
23  SbgStreamBuffer inputStream;
24  uint8_t outputBuffer[SBG_ECOM_MAX_BUFFER_SIZE];
25  SbgStreamBuffer outputStream;
26 
27  //
28  // Test that the input pointer are valid
29  //
30  if ((pHandle) && (pConf))
31  {
32  //
33  // Send the command three times
34  //
35  for (trial = 0; trial < pHandle->numTrials; trial++)
36  {
37 
38  //
39  // Initialize output stream buffer
40  //
41  sbgStreamBufferInitForWrite(&outputStream, &outputBuffer, sizeof(outputBuffer));
42 
43  //
44  // Build payload
45  //
46  sbgStreamBufferWriteUint8LE(&outputStream, (uint8_t)outputPort);
47  sbgStreamBufferWriteUint8LE(&outputStream, (uint8_t)msgId);
48  sbgStreamBufferWriteUint8LE(&outputStream, (uint8_t)classId);
49 
50  //
51  // Send the command and the prepared payload
52  //
53  errorCode = sbgEComProtocolSend(&pHandle->protocolHandle, SBG_ECOM_CLASS_LOG_CMD_0, SBG_ECOM_CMD_OUTPUT_CONF, sbgStreamBufferGetLinkedBuffer(&outputStream), sbgStreamBufferGetLength(&outputStream));
54 
55  //
56  // Make sure that the command has been sent
57  //
58  if (errorCode == SBG_NO_ERROR)
59  {
60  //
61  // Try to read the device answer for 500 ms
62  //
63  errorCode = sbgEComReceiveCmd(pHandle, SBG_ECOM_CLASS_LOG_CMD_0, SBG_ECOM_CMD_OUTPUT_CONF, receivedBuffer, &receivedSize, sizeof(receivedBuffer), pHandle->cmdDefaultTimeOut);
64 
65  //
66  // Test if we have received a SBG_ECOM_CMD_OUTPUT_CONF command
67  //
68  if (errorCode == SBG_NO_ERROR)
69  {
70  //
71  // Initialize stream buffer to read parameters
72  //
73  sbgStreamBufferInitForRead(&inputStream, receivedBuffer, receivedSize);
74 
75  //
76  // Read parameters
77  // First is returned outputPort, then messageId, classId rate and the output configuration at last.
78  //
79  outputPort = (SbgEComOutputPort)sbgStreamBufferReadUint8LE(&inputStream);
80  msgId = sbgStreamBufferReadUint8LE(&inputStream);
81  classId = (SbgEComClass)sbgStreamBufferReadUint8LE(&inputStream);
82  *pConf = (SbgEComOutputMode)sbgStreamBufferReadUint16LE(&inputStream);
83 
84  //
85  // The command has been executed successfully so return
86  //
87  break;
88  }
89  }
90  else
91  {
92  //
93  // We have a write error so exit the try loop
94  //
95  break;
96  }
97  }
98  }
99  else
100  {
101  //
102  // Null pointer.
103  //
104  errorCode = SBG_NULL_POINTER;
105  }
106 
107  return errorCode;
108 }
109 
119 SbgErrorCode sbgEComCmdOutputSetConf(SbgEComHandle *pHandle, SbgEComOutputPort outputPort, SbgEComClass classId, SbgEComMsgId msgId, SbgEComOutputMode conf)
120 {
121  SbgErrorCode errorCode = SBG_NO_ERROR;
122  uint32_t trial;
123  uint8_t outputBuffer[SBG_ECOM_MAX_BUFFER_SIZE];
124  SbgStreamBuffer outputStream;
125 
126  //
127  // Test that the input pointer are valid
128  //
129  if (pHandle)
130  {
131  //
132  // Send the command three times
133  //
134  for (trial = 0; trial < pHandle->numTrials; trial++)
135  {
136  //
137  // Init stream buffer for output
138  //
139  sbgStreamBufferInitForWrite(&outputStream, outputBuffer, sizeof(outputBuffer));
140 
141  //
142  // Build payload
143  //
144  sbgStreamBufferWriteUint8LE(&outputStream, (uint8_t)outputPort);
145  sbgStreamBufferWriteUint8LE(&outputStream, (uint8_t)msgId);
146  sbgStreamBufferWriteUint8LE(&outputStream, (uint8_t)classId);
147  sbgStreamBufferWriteUint16LE(&outputStream, (uint16_t)conf);
148 
149  //
150  // Send the payload over ECom
151  //
152  errorCode = sbgEComProtocolSend(&pHandle->protocolHandle, SBG_ECOM_CLASS_LOG_CMD_0, SBG_ECOM_CMD_OUTPUT_CONF, sbgStreamBufferGetLinkedBuffer(&outputStream), sbgStreamBufferGetLength(&outputStream));
153 
154  //
155  // Make sure that the command has been sent
156  //
157  if (errorCode == SBG_NO_ERROR)
158  {
159  //
160  // Try to read the device answer for 500 ms
161  //
162  errorCode = sbgEComWaitForAck(pHandle, SBG_ECOM_CLASS_LOG_CMD_0, SBG_ECOM_CMD_OUTPUT_CONF, pHandle->cmdDefaultTimeOut);
163 
164  //
165  // Test if we have received a valid ACK
166  //
167  if (errorCode == SBG_NO_ERROR)
168  {
169  //
170  // The command has been executed successfully so return
171  //
172  break;
173  }
174  }
175  else
176  {
177  //
178  // We have a write error so exit the try loop
179  //
180  break;
181  }
182  }
183  }
184  else
185  {
186  //
187  // Invalid protocol handle.
188  //
189  errorCode = SBG_NULL_POINTER;
190  }
191 
192  return errorCode;
193 }
194 
203 SbgErrorCode sbgEComCmdOutputClassGetEnable(SbgEComHandle *pHandle, SbgEComOutputPort outputPort, SbgEComClass classId, bool *pEnable)
204 {
205  SbgErrorCode errorCode = SBG_NO_ERROR;
206  uint32_t trial;
207  size_t receivedSize;
208  uint8_t receivedBuffer[SBG_ECOM_MAX_BUFFER_SIZE];
209  SbgStreamBuffer inputStream;
210  uint8_t outputBuffer[SBG_ECOM_MAX_BUFFER_SIZE];
211  SbgStreamBuffer outputStream;
212 
213  //
214  // Test that the input pointer are valid
215  //
216  if ((pHandle) && (pEnable))
217  {
218  //
219  // Send the command three times
220  //
221  for (trial = 0; trial < pHandle->numTrials; trial++)
222  {
223 
224  //
225  // Initialize output stream buffer
226  //
227  sbgStreamBufferInitForWrite(&outputStream, &outputBuffer, sizeof(outputBuffer));
228 
229  //
230  // Build payload
231  //
232  sbgStreamBufferWriteUint8LE(&outputStream, (uint8_t)outputPort);
233  sbgStreamBufferWriteUint8LE(&outputStream, (uint8_t)classId);
234 
235  //
236  // Send the command and the prepared payload
237  //
238  errorCode = sbgEComProtocolSend(&pHandle->protocolHandle, SBG_ECOM_CLASS_LOG_CMD_0, SBG_ECOM_CMD_OUTPUT_CLASS_ENABLE, sbgStreamBufferGetLinkedBuffer(&outputStream), sbgStreamBufferGetLength(&outputStream));
239 
240  //
241  // Make sure that the command has been sent
242  //
243  if (errorCode == SBG_NO_ERROR)
244  {
245  //
246  // Try to read the device answer for 500 ms
247  //
248  errorCode = sbgEComReceiveCmd(pHandle, SBG_ECOM_CLASS_LOG_CMD_0, SBG_ECOM_CMD_OUTPUT_CLASS_ENABLE, receivedBuffer, &receivedSize, sizeof(receivedBuffer), pHandle->cmdDefaultTimeOut);
249 
250  //
251  // Test if we have received a correct answer
252  //
253  if (errorCode == SBG_NO_ERROR)
254  {
255  //
256  // Initialize stream buffer to read parameters
257  //
258  sbgStreamBufferInitForRead(&inputStream, receivedBuffer, receivedSize);
259 
260  //
261  // Read parameters
262  // First is returned outputPort, then messageId, classId rate and the output configuration at last.
263  //
264  outputPort = (SbgEComOutputPort)sbgStreamBufferReadUint8LE(&inputStream);
265  classId = (SbgEComClass)sbgStreamBufferReadUint8LE(&inputStream);
266  *pEnable = (bool)sbgStreamBufferReadUint8LE(&inputStream);
267 
268  //
269  // The command has been executed successfully so return
270  //
271  break;
272  }
273  }
274  else
275  {
276  //
277  // We have a write error so exit the try loop
278  //
279  break;
280  }
281  }
282  }
283  else
284  {
285  //
286  // Null pointer.
287  //
288  errorCode = SBG_NULL_POINTER;
289  }
290 
291  return errorCode;
292 }
293 
302 SbgErrorCode sbgEComCmdOutputClassSetEnable(SbgEComHandle *pHandle, SbgEComOutputPort outputPort, SbgEComClass classId, bool enable)
303 {
304  SbgErrorCode errorCode = SBG_NO_ERROR;
305  uint32_t trial;
306  uint8_t outputBuffer[SBG_ECOM_MAX_BUFFER_SIZE];
307  SbgStreamBuffer outputStream;
308 
309  //
310  // Test that the input pointer are valid
311  //
312  if (pHandle)
313  {
314  //
315  // Send the command three times
316  //
317  for (trial = 0; trial < pHandle->numTrials; trial++)
318  {
319  //
320  // Init stream buffer for output
321  //
322  sbgStreamBufferInitForWrite(&outputStream, outputBuffer, sizeof(outputBuffer));
323 
324  //
325  // Build payload
326  //
327  sbgStreamBufferWriteUint8LE(&outputStream, (uint8_t)outputPort);
328  sbgStreamBufferWriteUint8LE(&outputStream, (uint8_t)classId);
329  sbgStreamBufferWriteUint8LE(&outputStream, (uint8_t)enable);
330 
331  //
332  // Send the payload over ECom
333  //
334  errorCode = sbgEComProtocolSend(&pHandle->protocolHandle, SBG_ECOM_CLASS_LOG_CMD_0, SBG_ECOM_CMD_OUTPUT_CLASS_ENABLE, sbgStreamBufferGetLinkedBuffer(&outputStream), sbgStreamBufferGetLength(&outputStream));
335 
336  //
337  // Make sure that the command has been sent
338  //
339  if (errorCode == SBG_NO_ERROR)
340  {
341  //
342  // Try to read the device answer for 500 ms
343  //
344  errorCode = sbgEComWaitForAck(pHandle, SBG_ECOM_CLASS_LOG_CMD_0, SBG_ECOM_CMD_OUTPUT_CLASS_ENABLE, pHandle->cmdDefaultTimeOut);
345 
346  //
347  // Test if we have received a valid ACK
348  //
349  if (errorCode == SBG_NO_ERROR)
350  {
351  //
352  // The command has been executed successfully so return
353  //
354  break;
355  }
356  }
357  else
358  {
359  //
360  // We have a write error so exit the try loop
361  //
362  break;
363  }
364  }
365  }
366  else
367  {
368  //
369  // Invalid protocol handle.
370  //
371  errorCode = SBG_NULL_POINTER;
372  }
373 
374  return errorCode;
375 }
376 
386 SbgErrorCode sbgEComCmdCanOutputGetConf(SbgEComHandle *pHandle, SbgECanMessageId internalId, SbgEComOutputMode *pMode, uint32_t *pUserId, bool *pExtended)
387 {
388  SbgErrorCode errorCode = SBG_NO_ERROR;
389  uint32_t trial;
390  size_t receivedSize;
391  uint8_t receivedBuffer[SBG_ECOM_MAX_BUFFER_SIZE];
392  uint8_t outputBuffer[2];
393  SbgStreamBuffer outputStream;
394  SbgStreamBuffer inputStream;
395 
396  assert(pHandle);
397  assert(pMode);
398  assert(pUserId);
399  assert(pExtended);
400 
401  //
402  // Send the command three times
403  //
404  for (trial = 0; trial < pHandle->numTrials; trial++)
405  {
406  //
407  // Send the command and a 2-byte payload
408  //
409  sbgStreamBufferInitForWrite(&outputStream, outputBuffer, sizeof(outputBuffer));
410  sbgStreamBufferWriteUint16LE(&outputStream, internalId);
411  errorCode = sbgEComProtocolSend(&pHandle->protocolHandle, SBG_ECOM_CLASS_LOG_CMD_0, SBG_ECOM_CMD_CAN_OUTPUT_CONF, sbgStreamBufferGetLinkedBuffer(&outputStream), sbgStreamBufferGetLength(&outputStream));
412 
413  //
414  // Make sure that the command has been sent
415  //
416  if (errorCode == SBG_NO_ERROR)
417  {
418  //
419  // Try to read the device answer for 500 ms
420  //
421  errorCode = sbgEComReceiveCmd(pHandle, SBG_ECOM_CLASS_LOG_CMD_0, SBG_ECOM_CMD_CAN_OUTPUT_CONF, receivedBuffer, &receivedSize, sizeof(receivedBuffer), pHandle->cmdDefaultTimeOut);
422 
423  //
424  // Test if we have received a correct answer
425  //
426  if (errorCode == SBG_NO_ERROR)
427  {
428  //
429  // Initialize stream buffer to read parameters
430  //
431  sbgStreamBufferInitForRead(&inputStream, receivedBuffer, receivedSize);
432 
433  //
434  // Read parameters
435  // First is returned outputPort, then messageId, classId rate and the output configuration at last.
436  //
437  internalId = (SbgECanMessageId)sbgStreamBufferReadUint16LE(&inputStream);
438  *pMode = (SbgEComOutputMode)sbgStreamBufferReadUint16LE(&inputStream);
439  *pUserId = sbgStreamBufferReadUint32LE(&inputStream);
440  *pExtended = (bool)sbgStreamBufferReadUint8LE(&inputStream);
441 
442  //
443  // The command has been executed successfully so return
444  //
445  break;
446  }
447  }
448  else
449  {
450  //
451  // We have a write error so exit the try loop
452  //
453  break;
454  }
455  }
456 
457  return errorCode;
458 }
459 
469 SbgErrorCode sbgEComCmdCanOutputSetConf(SbgEComHandle *pHandle, SbgECanMessageId internalId, SbgEComOutputMode mode, uint32_t userId, bool extended)
470 {
471  SbgErrorCode errorCode = SBG_NO_ERROR;
472  uint32_t trial;
473  uint8_t outputBuffer[SBG_ECOM_MAX_BUFFER_SIZE];
474  SbgStreamBuffer outputStream;
475 
476  assert(pHandle);
477 
478  //
479  // Send the command three times
480  //
481  for (trial = 0; trial < pHandle->numTrials; trial++)
482  {
483  //
484  // Init stream buffer for output
485  //
486  sbgStreamBufferInitForWrite(&outputStream, outputBuffer, sizeof(outputBuffer));
487 
488  //
489  // Build payload
490  //
491  sbgStreamBufferWriteUint16LE(&outputStream, (uint16_t)internalId);
492  sbgStreamBufferWriteUint16LE(&outputStream, (uint16_t)mode);
493  sbgStreamBufferWriteUint32LE(&outputStream, userId);
494  sbgStreamBufferWriteUint8LE(&outputStream, (uint8_t)extended);
495 
496  //
497  // Send the payload over ECom
498  //
499  errorCode = sbgEComProtocolSend(&pHandle->protocolHandle, SBG_ECOM_CLASS_LOG_CMD_0, SBG_ECOM_CMD_CAN_OUTPUT_CONF, sbgStreamBufferGetLinkedBuffer(&outputStream), sbgStreamBufferGetLength(&outputStream));
500 
501  //
502  // Make sure that the command has been sent
503  //
504  if (errorCode == SBG_NO_ERROR)
505  {
506  //
507  // Try to read the device answer for 500 ms
508  //
509  errorCode = sbgEComWaitForAck(pHandle, SBG_ECOM_CLASS_LOG_CMD_0, SBG_ECOM_CMD_CAN_OUTPUT_CONF, pHandle->cmdDefaultTimeOut);
510 
511  //
512  // Test if we have received a valid ACK
513  //
514  if (errorCode == SBG_NO_ERROR)
515  {
516  //
517  // The command has been executed successfully so return
518  //
519  break;
520  }
521  }
522  else
523  {
524  //
525  // We have a write error so exit the try loop
526  //
527  break;
528  }
529  }
530 
531  return errorCode;
532 }
533 
541 SbgErrorCode sbgEComCmdOutputGetLegacyConf(SbgEComHandle *pHandle, SbgEComOutputPort outputPort, SbgEComLegacyConf *pConf)
542 {
543  SbgErrorCode errorCode = SBG_NO_ERROR;
544  uint32_t trial;
545  size_t receivedSize;
546  uint8_t receivedBuffer[SBG_ECOM_MAX_BUFFER_SIZE];
547  SbgStreamBuffer inputStream;
548  uint8_t outputBuffer[1];
549  SbgStreamBuffer outputStream;
550 
551  assert(pHandle);
552  assert(pConf);
553 
554  //
555  // Send the command three times
556  //
557  for (trial = 0; trial < pHandle->numTrials; trial++)
558  {
559  //
560  // Initialize output stream buffer
561  //
562  sbgStreamBufferInitForWrite(&outputStream, &outputBuffer, sizeof(outputBuffer));
563 
564  //
565  // Build payload
566  //
567  sbgStreamBufferWriteUint8LE(&outputStream, (uint8_t)outputPort);
568 
569  //
570  // Send the command and the prepared payload
571  //
572  errorCode = sbgEComProtocolSend(&pHandle->protocolHandle, SBG_ECOM_CLASS_LOG_CMD_0, SBG_ECOM_CMD_LEGACY_CONT_OUTPUT_CONF, sbgStreamBufferGetLinkedBuffer(&outputStream), sbgStreamBufferGetLength(&outputStream));
573 
574  //
575  // Make sure that the command has been sent
576  //
577  if (errorCode == SBG_NO_ERROR)
578  {
579  //
580  // Try to read the device answer for 500 ms
581  //
582  errorCode = sbgEComReceiveCmd(pHandle, SBG_ECOM_CLASS_LOG_CMD_0, SBG_ECOM_CMD_LEGACY_CONT_OUTPUT_CONF, receivedBuffer, &receivedSize, sizeof(receivedBuffer), pHandle->cmdDefaultTimeOut);
583 
584  //
585  // Test if we have received a correct command
586  //
587  if (errorCode == SBG_NO_ERROR)
588  {
589  //
590  // Initialize stream buffer to read parameters
591  //
592  sbgStreamBufferInitForRead(&inputStream, receivedBuffer, receivedSize);
593 
594  //
595  // Read parameters
596  // First is returned outputPort, then messageId, classId rate and the output configuration at last.
597  //
598  outputPort = (SbgEComOutputPort)sbgStreamBufferReadUint8LE(&inputStream);
599  pConf->mask = sbgStreamBufferReadUint32LE(&inputStream);
600  pConf->format = (SbgEComLegacyFormat)sbgStreamBufferReadUint8LE(&inputStream);
601  pConf->endian = (SbgEComLegacyEndian)sbgStreamBufferReadUint8LE(&inputStream);
602  pConf->mode = (SbgEComOutputMode)sbgStreamBufferReadUint16LE(&inputStream);
603 
604  //
605  // The command has been executed successfully so return
606  //
607  break;
608  }
609  }
610  else
611  {
612  //
613  // We have a write error so exit the try loop
614  //
615  break;
616  }
617  }
618 
619  return errorCode;
620 }
621 
629 SbgErrorCode sbgEComCmdOutputSetLegacyConf(SbgEComHandle *pHandle, SbgEComOutputPort outputPort, const SbgEComLegacyConf *pConf)
630 {
631  SbgErrorCode errorCode = SBG_NO_ERROR;
632  uint32_t trial;
633  uint8_t outputBuffer[9];
634  SbgStreamBuffer outputStream;
635 
636  assert(pHandle);
637  assert(pConf);
638 
639  //
640  // Send the command three times
641  //
642  for (trial = 0; trial < pHandle->numTrials; trial++)
643  {
644  //
645  // Init stream buffer for output
646  //
647  sbgStreamBufferInitForWrite(&outputStream, outputBuffer, sizeof(outputBuffer));
648 
649  //
650  // Build payload
651  //
652  sbgStreamBufferWriteUint8LE(&outputStream, (uint8_t)outputPort);
653  sbgStreamBufferWriteUint32LE(&outputStream, pConf->mask);
654  sbgStreamBufferWriteUint8LE(&outputStream, (uint8_t)pConf->format);
655  sbgStreamBufferWriteUint8LE(&outputStream, (uint8_t)pConf->endian);
656  sbgStreamBufferWriteUint16LE(&outputStream, (uint16_t)pConf->mode);
657 
658  //
659  // Send the payload over ECom
660  //
661  errorCode = sbgEComProtocolSend(&pHandle->protocolHandle, SBG_ECOM_CLASS_LOG_CMD_0, SBG_ECOM_CMD_LEGACY_CONT_OUTPUT_CONF, sbgStreamBufferGetLinkedBuffer(&outputStream), sbgStreamBufferGetLength(&outputStream));
662 
663  //
664  // Make sure that the command has been sent
665  //
666  if (errorCode == SBG_NO_ERROR)
667  {
668  //
669  // Try to read the device answer for 500 ms
670  //
671  errorCode = sbgEComWaitForAck(pHandle, SBG_ECOM_CLASS_LOG_CMD_0, SBG_ECOM_CMD_LEGACY_CONT_OUTPUT_CONF, pHandle->cmdDefaultTimeOut);
672 
673  //
674  // Test if we have received a valid ACK
675  //
676  if (errorCode == SBG_NO_ERROR)
677  {
678  //
679  // The command has been executed successfully so return
680  //
681  break;
682  }
683  }
684  else
685  {
686  //
687  // We have a write error so exit the try loop
688  //
689  break;
690  }
691  }
692 
693  return errorCode;
694 }
695 
703 SbgErrorCode sbgEComCmdOutputGetNmeaTalkerId(SbgEComHandle *pHandle, SbgEComOutputPort outputPort, char nmeaTalkerId[2])
704 {
705  SbgErrorCode errorCode = SBG_NO_ERROR;
706  uint32_t trial;
707  size_t receivedSize;
708  uint8_t receivedBuffer[SBG_ECOM_MAX_BUFFER_SIZE];
709  SbgStreamBuffer inputStream;
710  uint8_t outputBuffer[1];
711  SbgStreamBuffer outputStream;
712 
713  assert(pHandle);
714  assert(nmeaTalkerId);
715 
716  //
717  // Send the command three times
718  //
719  for (trial = 0; trial < pHandle->numTrials; trial++)
720  {
721  //
722  // Send the command with the output port as a 1-byte payload
723  //
724  sbgStreamBufferInitForWrite(&outputStream, outputBuffer, sizeof(outputBuffer));
725  sbgStreamBufferWriteUint8(&outputStream, outputPort);
726  errorCode = sbgEComProtocolSend(&pHandle->protocolHandle, SBG_ECOM_CLASS_LOG_CMD_0, SBG_ECOM_CMD_NMEA_TALKER_ID, sbgStreamBufferGetLinkedBuffer(&outputStream), sbgStreamBufferGetLength(&outputStream));
727 
728  //
729  // Make sure that the command has been sent
730  //
731  if (errorCode == SBG_NO_ERROR)
732  {
733  //
734  // Try to read the device answer for 500 ms
735  //
736  errorCode = sbgEComReceiveCmd(pHandle, SBG_ECOM_CLASS_LOG_CMD_0, SBG_ECOM_CMD_NMEA_TALKER_ID, receivedBuffer, &receivedSize, sizeof(receivedBuffer), pHandle->cmdDefaultTimeOut);
737 
738  //
739  // Test if we have received a SBG_ECOM_CMD_NMEA_TALKER_ID command
740  //
741  if (errorCode == SBG_NO_ERROR)
742  {
743  //
744  // Initialize stream buffer to read parameters
745  //
746  sbgStreamBufferInitForRead(&inputStream, receivedBuffer, receivedSize);
747 
748  //
749  // Read parameters
750  //
751  outputPort = (SbgEComOutputPort)sbgStreamBufferReadUint8LE(&inputStream);
752  nmeaTalkerId[0] = (char)sbgStreamBufferReadUint8LE(&inputStream);
753  nmeaTalkerId[1] = (char)sbgStreamBufferReadUint8LE(&inputStream);
754 
755  //
756  // The command has been executed successfully so return
757  //
758  break;
759  }
760  }
761  else
762  {
763  //
764  // We have a write error so exit the try loop
765  //
766  break;
767  }
768  }
769 
770  return errorCode;
771 }
772 
780 SbgErrorCode sbgEComCmdOutputSetNmeaTalkerId(SbgEComHandle *pHandle, SbgEComOutputPort outputPort, const char nmeaTalkerId[2])
781 {
782  SbgErrorCode errorCode = SBG_NO_ERROR;
783  uint32_t trial;
784  uint8_t outputBuffer[3];
785  SbgStreamBuffer outputStream;
786 
787  assert(pHandle);
788  assert(nmeaTalkerId);
789 
790  //
791  // Send the command three times
792  //
793  for (trial = 0; trial < pHandle->numTrials; trial++)
794  {
795  //
796  // Init stream buffer for output
797  //
798  sbgStreamBufferInitForWrite(&outputStream, outputBuffer, sizeof(outputBuffer));
799 
800  //
801  // Build payload
802  //
803  sbgStreamBufferWriteUint8LE(&outputStream, (uint8_t)outputPort);
804  sbgStreamBufferWriteUint8LE(&outputStream, (uint8_t)(nmeaTalkerId[0]));
805  sbgStreamBufferWriteUint8LE(&outputStream, (uint8_t)(nmeaTalkerId[1]));
806 
807  //
808  // Send the payload over ECom
809  //
810  errorCode = sbgEComProtocolSend(&pHandle->protocolHandle, SBG_ECOM_CLASS_LOG_CMD_0, SBG_ECOM_CMD_NMEA_TALKER_ID, sbgStreamBufferGetLinkedBuffer(&outputStream), sbgStreamBufferGetLength(&outputStream));
811 
812  //
813  // Make sure that the command has been sent
814  //
815  if (errorCode == SBG_NO_ERROR)
816  {
817  //
818  // Try to read the device answer for 500 ms
819  //
820  errorCode = sbgEComWaitForAck(pHandle, SBG_ECOM_CLASS_LOG_CMD_0, SBG_ECOM_CMD_NMEA_TALKER_ID, pHandle->cmdDefaultTimeOut);
821 
822  //
823  // Test if we have received a valid ACK
824  //
825  if (errorCode == SBG_NO_ERROR)
826  {
827  //
828  // The command has been executed successfully so return
829  //
830  break;
831  }
832  }
833  else
834  {
835  //
836  // We have a write error so exit the try loop
837  //
838  break;
839  }
840  }
841 
842  return errorCode;
843 }
sbgEComCmdCanOutputSetConf
SbgErrorCode sbgEComCmdCanOutputSetConf(SbgEComHandle *pHandle, SbgECanMessageId internalId, SbgEComOutputMode mode, uint32_t userId, bool extended)
Definition: sbgEComCmdOutput.c:469
sbgStreamBufferReadUint8LE
#define sbgStreamBufferReadUint8LE
Definition: sbgStreamBufferCommon.h:141
sbgEComWaitForAck
SbgErrorCode sbgEComWaitForAck(SbgEComHandle *pHandle, uint8_t msgClass, uint8_t msg, uint32_t timeOut)
Definition: sbgEComCmdCommon.c:278
SbgEComLegacyEndian
enum _SbgEComLegacyEndian SbgEComLegacyEndian
sbgStreamBufferWriteUint8
SBG_INLINE SbgErrorCode sbgStreamBufferWriteUint8(SbgStreamBuffer *pHandle, uint8_t value)
Definition: sbgStreamBufferCommon.h:726
_SbgEComLegacyConf::format
SbgEComLegacyFormat format
Definition: sbgEComCmdOutput.h:107
sbgStreamBufferInitForWrite
SBG_INLINE SbgErrorCode sbgStreamBufferInitForWrite(SbgStreamBuffer *pHandle, void *pLinkedBuffer, size_t bufferSize)
Definition: sbgStreamBufferCommon.h:208
_SbgEComLegacyConf::endian
SbgEComLegacyEndian endian
Definition: sbgEComCmdOutput.h:108
sbgEComCmdOutputGetConf
SbgErrorCode sbgEComCmdOutputGetConf(SbgEComHandle *pHandle, SbgEComOutputPort outputPort, SbgEComClass classId, SbgEComMsgId msgId, SbgEComOutputMode *pConf)
Definition: sbgEComCmdOutput.c:17
sbgStreamBufferReadUint16LE
SBG_INLINE uint16_t sbgStreamBufferReadUint16LE(SbgStreamBuffer *pHandle)
Definition: sbgStreamBufferLE.h:106
SbgEComOutputMode
enum _SbgEComOutputMode SbgEComOutputMode
sbgEComCmdOutputSetConf
SbgErrorCode sbgEComCmdOutputSetConf(SbgEComHandle *pHandle, SbgEComOutputPort outputPort, SbgEComClass classId, SbgEComMsgId msgId, SbgEComOutputMode conf)
Definition: sbgEComCmdOutput.c:119
sbgEComCmdOutputGetNmeaTalkerId
SbgErrorCode sbgEComCmdOutputGetNmeaTalkerId(SbgEComHandle *pHandle, SbgEComOutputPort outputPort, char nmeaTalkerId[2])
Definition: sbgEComCmdOutput.c:703
SbgECanMessageId
enum _SbgECanMessageId SbgECanMessageId
SBG_ECOM_MAX_BUFFER_SIZE
#define SBG_ECOM_MAX_BUFFER_SIZE
Implementation of the Ekinox binary communication protocol. You can access low-level communication w...
Definition: sbgEComProtocol.h:35
sbgStreamBufferGetLinkedBuffer
SBG_INLINE void * sbgStreamBufferGetLinkedBuffer(SbgStreamBuffer *pHandle)
Definition: sbgStreamBufferCommon.h:467
SBG_ECOM_CMD_LEGACY_CONT_OUTPUT_CONF
@ SBG_ECOM_CMD_LEGACY_CONT_OUTPUT_CONF
Definition: sbgEComIds.h:247
SBG_ECOM_CLASS_LOG_CMD_0
@ SBG_ECOM_CLASS_LOG_CMD_0
Definition: sbgEComIds.h:59
sbgStreamBufferWriteUint16LE
SBG_INLINE SbgErrorCode sbgStreamBufferWriteUint16LE(SbgStreamBuffer *pHandle, uint16_t value)
Definition: sbgStreamBufferLE.h:1250
sbgEComReceiveCmd
SbgErrorCode sbgEComReceiveCmd(SbgEComHandle *pHandle, uint8_t msgClass, uint8_t msg, void *pData, size_t *pSize, size_t maxSize, uint32_t timeOut)
Definition: sbgEComCmdCommon.c:174
SbgEComClass
enum _SbgEComClass SbgEComClass
SbgEComOutputPort
enum _SbgEComOutputPort SbgEComOutputPort
This file implements SbgECom commands related to outputs.
sbgEComCmdCanOutputGetConf
SbgErrorCode sbgEComCmdCanOutputGetConf(SbgEComHandle *pHandle, SbgECanMessageId internalId, SbgEComOutputMode *pMode, uint32_t *pUserId, bool *pExtended)
Definition: sbgEComCmdOutput.c:386
sbgStreamBufferReadUint32LE
SBG_INLINE uint32_t sbgStreamBufferReadUint32LE(SbgStreamBuffer *pHandle)
Definition: sbgStreamBufferLE.h:386
SBG_NULL_POINTER
@ SBG_NULL_POINTER
Definition: sbgErrorCodes.h:37
sbgEComCmdOutputClassGetEnable
SbgErrorCode sbgEComCmdOutputClassGetEnable(SbgEComHandle *pHandle, SbgEComOutputPort outputPort, SbgEComClass classId, bool *pEnable)
Definition: sbgEComCmdOutput.c:203
_SbgEComHandle::cmdDefaultTimeOut
uint32_t cmdDefaultTimeOut
Definition: sbgECom.h:78
_SbgEComHandle::protocolHandle
SbgEComProtocol protocolHandle
Definition: sbgECom.h:72
sbgEComCmdOutputGetLegacyConf
SbgErrorCode sbgEComCmdOutputGetLegacyConf(SbgEComHandle *pHandle, SbgEComOutputPort outputPort, SbgEComLegacyConf *pConf)
Definition: sbgEComCmdOutput.c:541
sbgEComCmdOutputSetNmeaTalkerId
SbgErrorCode sbgEComCmdOutputSetNmeaTalkerId(SbgEComHandle *pHandle, SbgEComOutputPort outputPort, const char nmeaTalkerId[2])
Definition: sbgEComCmdOutput.c:780
_SbgEComHandle
Definition: sbgECom.h:70
SbgEComLegacyFormat
enum _SbgEComLegacyFormat SbgEComLegacyFormat
_SbgEComHandle::numTrials
uint32_t numTrials
Definition: sbgECom.h:77
_SbgStreamBuffer
Definition: sbgStreamBufferCommon.h:188
sbgStreamBufferWriteUint8LE
#define sbgStreamBufferWriteUint8LE
Definition: sbgStreamBufferCommon.h:146
sbgStreamBufferGetLength
SBG_INLINE size_t sbgStreamBufferGetLength(SbgStreamBuffer *pHandle)
Definition: sbgStreamBufferCommon.h:333
SBG_NO_ERROR
@ SBG_NO_ERROR
Definition: sbgErrorCodes.h:35
sbgStreamBuffer.h
SBG_ECOM_CMD_OUTPUT_CONF
@ SBG_ECOM_CMD_OUTPUT_CONF
Definition: sbgEComIds.h:246
SbgEComMsgId
uint8_t SbgEComMsgId
Definition: sbgEComIds.h:289
sbgEComCmdOutputClassSetEnable
SbgErrorCode sbgEComCmdOutputClassSetEnable(SbgEComHandle *pHandle, SbgEComOutputPort outputPort, SbgEComClass classId, bool enable)
Definition: sbgEComCmdOutput.c:302
_SbgEComLegacyConf
Definition: sbgEComCmdOutput.h:104
SbgErrorCode
enum _SbgErrorCode SbgErrorCode
Header file that defines all error codes for SBG Systems libraries.
sbgEComCmdOutputSetLegacyConf
SbgErrorCode sbgEComCmdOutputSetLegacyConf(SbgEComHandle *pHandle, SbgEComOutputPort outputPort, const SbgEComLegacyConf *pConf)
Definition: sbgEComCmdOutput.c:629
sbgEComProtocolSend
SbgErrorCode sbgEComProtocolSend(SbgEComProtocol *pHandle, uint8_t msgClass, uint8_t msg, const void *pData, size_t size)
Definition: sbgEComProtocol.c:60
sbgStreamBufferInitForRead
SBG_INLINE SbgErrorCode sbgStreamBufferInitForRead(SbgStreamBuffer *pHandle, const void *pLinkedBuffer, size_t bufferSize)
Definition: sbgStreamBufferCommon.h:242
SBG_ECOM_CMD_OUTPUT_CLASS_ENABLE
@ SBG_ECOM_CMD_OUTPUT_CLASS_ENABLE
Definition: sbgEComIds.h:259
_SbgEComLegacyConf::mode
SbgEComOutputMode mode
Definition: sbgEComCmdOutput.h:109
sbgEComCmdOutput.h
SBG_ECOM_CMD_NMEA_TALKER_ID
@ SBG_ECOM_CMD_NMEA_TALKER_ID
Definition: sbgEComIds.h:245
sbgStreamBufferWriteUint32LE
SBG_INLINE SbgErrorCode sbgStreamBufferWriteUint32LE(SbgStreamBuffer *pHandle, uint32_t value)
Definition: sbgStreamBufferLE.h:1499
SBG_ECOM_CMD_CAN_OUTPUT_CONF
@ SBG_ECOM_CMD_CAN_OUTPUT_CONF
Definition: sbgEComIds.h:238
_SbgEComLegacyConf::mask
uint32_t mask
Definition: sbgEComCmdOutput.h:106

sbg_driver
Author(s): SBG Systems
autogenerated on Fri Oct 11 2024 02:13:40