Choco OS  V.0.16.9.0
Join to the chocolate world
oc_uart_lld.c
1 
27 #include <oc_uart_lld.h>
28 #include <oc_mem_lld.h>
29 #include <oc_bits.h>
30 #include <oc_gpio_mslld.h>
31 #include <oc_array.h>
32 #include <oc_clock_lld.h>
33 #include <oc_dma_lld.h>
34 #include <oc_module.h>
35 #include <oc_lsf.h>
36 #include <oc_stdtypes.h>
37 #include <string.h>
38 #include <oc_compiler.h>
39 
45 #define _________________________________________MACROS_SECTION_____________________________________________________________________________
46 
47 #define USE_INTERRUPTS_FOR_TX false
48 #define SOFTWARE_RING_COUNT 10
49 #define IsRam(Address) (oC_LSF_IsRamAddress(Address) || oC_LSF_IsExternalAddress(Address))
50 #define IsRom(Address) oC_LSF_IsRomAddress(Address)
51 #define IsChannelCorrect(Channel) oC_Channel_IsCorrect(UART,Channel)
52 #define IsChannelPoweredOn(Channel) (oC_Machine_GetPowerStateForChannel(Channel) == oC_Power_On)
53 #define AreOperationsDisabled(Channel) (USARTx_CR1(Channel)->UE == 0)
54 #define AreOperationsEnabled(Channel) (USARTx_CR1(Channel)->UE == 1)
55 #define USARTx_CR1(Channel) oC_Machine_Register(Channel , USARTx_CR1)
56 #define USARTx_CR2(Channel) oC_Machine_Register(Channel , USARTx_CR2)
57 #define USARTx_CR3(Channel) oC_Machine_Register(Channel , USARTx_CR3)
58 #define USARTx_BRR(Channel) oC_Machine_Register(Channel , USARTx_BRR)
59 #define USARTx_TDR(Channel) oC_Machine_Register(Channel , USARTx_TDR)
60 #define USARTx_RDR(Channel) oC_Machine_Register(Channel , USARTx_RDR)
61 #define USARTx_ISR(Channel) oC_Machine_Register(Channel , USARTx_ISR)
62 #define USARTx_ICR(Channel) oC_Machine_Register(Channel , USARTx_ICR)
63 #define TransmitDataMovedToFifo(Channel) (USARTx_ISR(Channel)->TXE == 1)
64 #define ReceiveDataAvailable(Channel) (USARTx_ISR(Channel)->RXNE == 1)
65 #define RCC_DCKCFGR2 oC_Register(RCC,RCC_DCKCFGR2)
66 #define RxRing(Channel) SoftwareRxRings[oC_Channel_ToIndex(UART,Channel)]
67 #define IsSoftwareRxRingEmpty(Channel) (RxRing(Channel).Counter == 0)
68 #define IsSoftwareRxRingFull(Channel) (RxRing(Channel).Counter == SOFTWARE_RING_COUNT)
69 #define TxRing(Channel) SoftwareTxRings[oC_Channel_ToIndex(UART,Channel)]
70 #define IsSoftwareTxRingEmpty(Channel) (TxRing(Channel).Counter == 0)
71 #define IsSoftwareTxRingFull(Channel) (TxRing(Channel).Counter == SOFTWARE_RING_COUNT)
72 
73 
74 #undef _________________________________________MACROS_SECTION_____________________________________________________________________________
75 
81 #define _________________________________________TYPES_SECTION______________________________________________________________________________
82 
83 typedef struct
84 {
85  uint16_t Buffer[SOFTWARE_RING_COUNT];
86  uint16_t PutIndex;
87  uint16_t GetIndex;
88  uint16_t Counter;
89 } SoftwareRing_t;
90 
91 #undef _________________________________________TYPES_SECTION______________________________________________________________________________
92 
98 #define _________________________________________LOCAL_PROTOTYPES_SECTION___________________________________________________________________
99 
100 static inline void PutToSoftwareRing ( SoftwareRing_t * Ring , uint16_t Data );
101 static inline uint16_t GetFromSoftwareRing( SoftwareRing_t * Ring );
102 static inline void ClearSoftwareRing ( SoftwareRing_t * Ring );
103 
104 #undef _________________________________________LOCAL_PROTOTYPES_SECTION___________________________________________________________________
105 
106 
112 #define _________________________________________VARIABLES_SECTION__________________________________________________________________________
113 
114 static oC_UART_LLD_Interrupt_t RxNotEmptyHandler = NULL;
115 static oC_UART_LLD_Interrupt_t TxNotFullHandler = NULL;
116 static SoftwareRing_t SoftwareRxRings[oC_ModuleChannel_NumberOfElements(UART)];
117 static SoftwareRing_t SoftwareTxRings[oC_ModuleChannel_NumberOfElements(UART)];
118 #if oC_ModuleChannel_NumberOfElements(UART) <= 8
119 static uint8_t UsedChannels = 0;
120 #elif oC_ModuleChannel_NumberOfElements(UART) <= 16
121 static uint16_t UsedChannels = 0;
122 #elif oC_ModuleChannel_NumberOfElements(UART) <= 32
123 static uint32_t UsedChannels = 0;
124 #elif oC_ModuleChannel_NumberOfElements(UART) <= 64
125 static uint64_t UsedChannels = 0;
126 #else
127 # error Number of UART channels is too big (max 64)
128 #endif
129 
130 #undef _________________________________________VARIABLES_SECTION__________________________________________________________________________
131 
137 #define _________________________________________FUNCTIONS_SECTION__________________________________________________________________________
138 
139 //==========================================================================================================================================
144 //==========================================================================================================================================
145 bool oC_UART_LLD_IsChannelCorrect( oC_UART_Channel_t Channel )
146 {
147  return oC_Channel_IsCorrect(UART,Channel);
148 }
149 
150 //==========================================================================================================================================
155 //==========================================================================================================================================
156 bool oC_UART_LLD_IsChannelIndexCorrect( oC_UART_LLD_ChannelIndex_t ChannelIndex )
157 {
158  return ChannelIndex < oC_ModuleChannel_NumberOfElements(UART);
159 }
160 
161 //==========================================================================================================================================
166 //==========================================================================================================================================
167 oC_UART_LLD_ChannelIndex_t oC_UART_LLD_ChannelToChannelIndex( oC_UART_Channel_t Channel )
168 {
169  return oC_Channel_ToIndex(UART,Channel);
170 }
171 
172 //==========================================================================================================================================
177 //==========================================================================================================================================
178 oC_UART_Channel_t oC_UART_LLD_ChannelIndexToChannel( oC_UART_LLD_ChannelIndex_t Channel )
179 {
180  return oC_Channel_FromIndex(UART,Channel);
181 }
182 
183 //==========================================================================================================================================
188 //==========================================================================================================================================
189 oC_UART_Channel_t oC_UART_LLD_GetChannelOfModulePin( oC_UART_Pin_t ModulePin )
190 {
191  return oC_ModulePin_GetChannel(ModulePin);
192 }
193 
194 //==========================================================================================================================================
199 //==========================================================================================================================================
200 oC_ErrorCode_t oC_UART_LLD_TurnOnDriver( void )
201 {
202  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
203 
204  oC_MCS_EnterCriticalSection();
205 
206  if(oC_Module_TurnOffVerification(&errorCode , oC_Module_UART_LLD))
207  {
208  oC_Module_TurnOn(oC_Module_UART_LLD);
209  errorCode = oC_ErrorCode_None;
210  RxNotEmptyHandler = NULL;
211  TxNotFullHandler = NULL;
212  UsedChannels = 0;
213 
214  memset(SoftwareRxRings,0,sizeof(SoftwareRxRings));
215  memset(SoftwareTxRings,0,sizeof(SoftwareTxRings));
216  }
217 
218  oC_MCS_ExitCriticalSection();
219 
220  return errorCode;
221 }
222 
223 //==========================================================================================================================================
228 //==========================================================================================================================================
229 oC_ErrorCode_t oC_UART_LLD_TurnOffDriver( void )
230 {
231  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
232 
233  oC_MCS_EnterCriticalSection();
234 
235  if(oC_Module_TurnOnVerification(&errorCode , oC_Module_UART_LLD))
236  {
237  oC_Module_TurnOff(oC_Module_UART_LLD);
238  errorCode = oC_ErrorCode_None;
239  }
240 
241  oC_MCS_ExitCriticalSection();
242 
243  return errorCode;
244 }
245 
246 //==========================================================================================================================================
251 //==========================================================================================================================================
252 oC_ErrorCode_t oC_UART_LLD_SetDriverInterruptHandlers( oC_UART_LLD_Interrupt_t RxNotEmpty , oC_UART_LLD_Interrupt_t TxNotFull)
253 {
254  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
255 
256  oC_MCS_EnterCriticalSection();
257 
258  if(oC_Module_TurnOnVerification(&errorCode , oC_Module_UART_LLD))
259  {
260  if(
261  ErrorCondition( IsRam(RxNotEmpty) || IsRom(RxNotEmpty) , oC_ErrorCode_WrongEventHandlerAddress) &&
262  ErrorCondition( RxNotEmptyHandler == NULL , oC_ErrorCode_InterruptHandlerAlreadySet) &&
263  ErrorCondition( IsRam(TxNotFull) || IsRom(TxNotFull) , oC_ErrorCode_WrongEventHandlerAddress) &&
264  ErrorCondition( TxNotFullHandler == NULL , oC_ErrorCode_InterruptHandlerAlreadySet)
265  )
266  {
267  RxNotEmptyHandler = RxNotEmpty;
268  TxNotFullHandler = TxNotFull;
269  errorCode = oC_ErrorCode_None;
270  }
271  }
272 
273  oC_MCS_ExitCriticalSection();
274 
275  return errorCode;
276 }
277 
278 //==========================================================================================================================================
283 //==========================================================================================================================================
284 oC_ErrorCode_t oC_UART_LLD_SetPower( oC_UART_Channel_t Channel , oC_Power_t Power )
285 {
286  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
287 
288  oC_MCS_EnterCriticalSection();
289 
290  if(oC_Module_TurnOnVerification(&errorCode , oC_Module_UART_LLD))
291  {
292  if(
293  ErrorCondition( IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel) &&
294  ErrorCondition( Power == oC_Power_On || Power == oC_Power_Off , oC_ErrorCode_PowerStateNotCorrect) &&
295  ErrorCondition( oC_Machine_SetPowerStateForChannel(Channel,Power) , oC_ErrorCode_CannotEnableChannel) &&
296  ErrorCondition( oC_Channel_EnableInterrupt(Channel,PeripheralInterrupt) , oC_ErrorCode_CannotEnableInterrupt)
297  )
298  {
299  oC_ChannelIndex_t channelIndex = oC_Channel_ToIndex(UART,Channel);
300 
301  oC_ASSERT(channelIndex < oC_ModuleChannel_NumberOfElements(UART));
302 
303  RCC_DCKCFGR2->Value &= ~(0x3<<(channelIndex*2));
304  RCC_DCKCFGR2->Value |= 0x1<<(channelIndex*2);
305 
306  oC_Channel_SetInterruptPriority(Channel,PeripheralInterrupt,oC_InterruptPriority_Maximum);
307 
308  errorCode = oC_ErrorCode_None;
309  }
310  }
311 
312  oC_MCS_ExitCriticalSection();
313 
314  return errorCode;
315 }
316 
317 //==========================================================================================================================================
322 //==========================================================================================================================================
323 oC_ErrorCode_t oC_UART_LLD_ReadPower( oC_UART_Channel_t Channel , oC_Power_t * outPower )
324 {
325  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
326 
327  oC_MCS_EnterCriticalSection();
328 
329  if(oC_Module_TurnOnVerification(&errorCode , oC_Module_UART_LLD))
330  {
331  if(
332  ErrorCondition( IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel) &&
333  ErrorCondition( IsRam(outPower) , oC_ErrorCode_OutputAddressNotInRAM)
334  )
335  {
336  *outPower = oC_Machine_GetPowerStateForChannel(Channel);
337  errorCode = oC_ErrorCode_None;
338  }
339  }
340 
341  oC_MCS_ExitCriticalSection();
342 
343  return errorCode;
344 }
345 //==========================================================================================================================================
350 //==========================================================================================================================================
351 oC_ErrorCode_t oC_UART_LLD_DisableOperations( oC_UART_Channel_t Channel )
352 {
353  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
354 
355  oC_MCS_EnterCriticalSection();
356 
357  if(oC_Module_TurnOnVerification(&errorCode , oC_Module_UART_LLD))
358  {
359  if(
360  ErrorCondition( IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel) &&
361  ErrorCondition( IsChannelPoweredOn(Channel) , oC_ErrorCode_ChannelNotPoweredOn)
362  )
363  {
364  USARTx_CR1(Channel)->UE = 0;
365  errorCode = oC_ErrorCode_None;
366  }
367  }
368 
369  oC_MCS_ExitCriticalSection();
370 
371  return errorCode;
372 }
373 
374 //==========================================================================================================================================
379 //==========================================================================================================================================
380 oC_ErrorCode_t oC_UART_LLD_EnableOperations( oC_UART_Channel_t Channel )
381 {
382  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
383 
384  oC_MCS_EnterCriticalSection();
385 
386  if(oC_Module_TurnOnVerification(&errorCode , oC_Module_UART_LLD))
387  {
388  if(
389  ErrorCondition( IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel) &&
390  ErrorCondition( IsChannelPoweredOn(Channel) , oC_ErrorCode_ChannelNotPoweredOn)
391  )
392  {
393  USARTx_CR1(Channel)->UE = 1;
394  USARTx_CR1(Channel)->TE = 1;
395  USARTx_CR1(Channel)->RE = 1;
396  USARTx_CR1(Channel)->RXNEIE = 1;
397  errorCode = oC_ErrorCode_None;
398  }
399  }
400 
401  oC_MCS_ExitCriticalSection();
402 
403  return errorCode;
404 }
405 
406 //==========================================================================================================================================
411 //==========================================================================================================================================
412 oC_ErrorCode_t oC_UART_LLD_RestoreDefaultStateOnChannel( oC_UART_Channel_t Channel )
413 {
414  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
415 
416  oC_MCS_EnterCriticalSection();
417 
418  if(oC_Module_TurnOnVerification(&errorCode , oC_Module_UART_LLD))
419  {
420  if(
421  ErrorCondition( IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel) &&
422  ErrorCondition( oC_Machine_SetPowerStateForChannel(Channel,oC_Power_Off) , oC_ErrorCode_CannotRestoreDefaultState)
423  )
424  {
425  errorCode = oC_ErrorCode_None;
426  }
427  }
428 
429  oC_MCS_ExitCriticalSection();
430 
431  return errorCode;
432 }
433 
434 //==========================================================================================================================================
439 //==========================================================================================================================================
440 oC_ErrorCode_t oC_UART_LLD_SetWordLength( oC_UART_Channel_t Channel , oC_UART_LLD_WordLength_t WordLength )
441 {
442  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
443 
444  oC_MCS_EnterCriticalSection();
445 
446  if(oC_Module_TurnOnVerification(&errorCode , oC_Module_UART_LLD))
447  {
448  if(
449  ErrorCondition( IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel) &&
450  ErrorCondition( IsChannelPoweredOn(Channel) , oC_ErrorCode_ChannelNotPoweredOn) &&
451  ErrorCondition( AreOperationsDisabled(Channel) , oC_ErrorCode_ChannelOperationsNotDisabled)
452  )
453  {
454  switch(WordLength)
455  {
456  case oC_UART_LLD_WordLength_5Bits:
457  errorCode = oC_ErrorCode_NotSupportedOnTargetMachine;
458  break;
459  case oC_UART_LLD_WordLength_6Bits:
460  errorCode = oC_ErrorCode_NotSupportedOnTargetMachine;
461  break;
462  case oC_UART_LLD_WordLength_7Bits:
463  USARTx_CR1(Channel)->M0 = 0;
464  USARTx_CR1(Channel)->M1 = 1;
465  errorCode = oC_ErrorCode_None;
466  break;
467  case oC_UART_LLD_WordLength_8Bits:
468  USARTx_CR1(Channel)->M0 = 0;
469  USARTx_CR1(Channel)->M1 = 0;
470  errorCode = oC_ErrorCode_None;
471  break;
472  case oC_UART_LLD_WordLength_9Bits:
473  USARTx_CR1(Channel)->M0 = 1;
474  USARTx_CR1(Channel)->M1 = 0;
475 
476  /* ***************************************************************** **
477  * Data in UART transmit/receive functions are given by char (uint8),
478  * Thanks to that transmission functions is quite simple. We will keep
479  * this until it is not very important. If you need 9bits transmission,
480  * please tell us with explanation, and we will try to fix this problem.
481  * ***************************************************************** */
482  errorCode = oC_ErrorCode_ProhibitedByArchitecture;
483  break;
484  default:
485  errorCode = oC_ErrorCode_WordLengthNotCorrect;
486  break;
487  }
488  }
489  }
490 
491  oC_MCS_ExitCriticalSection();
492 
493  return errorCode;
494 }
495 
496 //==========================================================================================================================================
501 //==========================================================================================================================================
502 oC_ErrorCode_t oC_UART_LLD_ReadWordLength( oC_UART_Channel_t Channel , oC_UART_LLD_WordLength_t * outWordLength )
503 {
504  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
505 
506  if(oC_Module_TurnOnVerification(&errorCode , oC_Module_UART_LLD))
507  {
508  if(
509  ErrorCondition( IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel) &&
510  ErrorCondition( IsChannelPoweredOn(Channel) , oC_ErrorCode_ChannelNotPoweredOn) &&
511  ErrorCondition( IsRam(outWordLength) , oC_ErrorCode_OutputAddressNotInRAM)
512  )
513  {
514  if( USARTx_CR1(Channel)->M0 == 0 && USARTx_CR1(Channel)->M1 == 0 )
515  {
516  *outWordLength = oC_UART_LLD_WordLength_8Bits;
517  errorCode = oC_ErrorCode_None;
518  }
519  else if( USARTx_CR1(Channel)->M0 == 0 && USARTx_CR1(Channel)->M1 == 1 )
520  {
521  *outWordLength = oC_UART_LLD_WordLength_7Bits;
522  errorCode = oC_ErrorCode_None;
523  }
524  else if( USARTx_CR1(Channel)->M0 == 1 && USARTx_CR1(Channel)->M1 == 0 )
525  {
526  *outWordLength = oC_UART_LLD_WordLength_9Bits;
527  errorCode = oC_ErrorCode_None;
528  }
529  else
530  {
531  errorCode = oC_ErrorCode_MachineCanBeDamaged;
532  }
533  }
534  }
535 
536  return errorCode;
537 }
538 
539 //==========================================================================================================================================
544 //==========================================================================================================================================
545 oC_ErrorCode_t oC_UART_LLD_SetBitRate( oC_UART_Channel_t Channel , uint32_t BitRate )
546 {
547  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
548 
549  oC_MCS_EnterCriticalSection();
550 
551  if(oC_Module_TurnOnVerification(&errorCode , oC_Module_UART_LLD))
552  {
553  if(
554  ErrorCondition( IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel) &&
555  ErrorCondition( IsChannelPoweredOn(Channel) , oC_ErrorCode_ChannelNotPoweredOn) &&
556  ErrorCondition( AreOperationsDisabled(Channel) , oC_ErrorCode_ChannelOperationsNotDisabled) &&
557  ErrorCondition( BitRate > 0 , oC_ErrorCode_BitRateNotCorrect)
558  )
559  {
560  oC_Frequency_t clockFrequency = oC_CLOCK_LLD_GetClockFrequency();
561  uint32_t usartDiv = (clockFrequency / BitRate);
562 
563  if(usartDiv <= UINT16_MAX)
564  {
565  USARTx_CR1(Channel)->OVER8 = 0;
566  USARTx_BRR(Channel)->BRR = usartDiv;
567  errorCode = oC_ErrorCode_None;
568  }
569  else
570  {
571  errorCode = oC_ErrorCode_BitRateNotSupported;
572  }
573  }
574  }
575 
576  oC_MCS_ExitCriticalSection();
577 
578  return errorCode;
579 }
580 
581 //==========================================================================================================================================
586 //==========================================================================================================================================
587 oC_ErrorCode_t oC_UART_LLD_ReadBitRate( oC_UART_Channel_t Channel , uint32_t * outBitRate )
588 {
589  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
590 
591  if(oC_Module_TurnOnVerification(&errorCode , oC_Module_UART_LLD))
592  {
593  if(
594  ErrorCondition( IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel) &&
595  ErrorCondition( IsChannelPoweredOn(Channel) , oC_ErrorCode_ChannelNotPoweredOn) &&
596  ErrorCondition( IsRam(outBitRate) , oC_ErrorCode_OutputAddressNotInRAM)
597  )
598  {
599  oC_Frequency_t clockFrequency = oC_CLOCK_LLD_GetClockFrequency();
600  uint32_t usartDiv = USARTx_BRR(Channel)->BRR;
601 
602  if(usartDiv > 0)
603  {
604  *outBitRate = clockFrequency / usartDiv;
605  }
606  else
607  {
608  *outBitRate = 0;
609  }
610 
611  errorCode = oC_ErrorCode_None;
612  }
613  }
614 
615  return errorCode;
616 }
617 
618 //==========================================================================================================================================
623 //==========================================================================================================================================
624 oC_ErrorCode_t oC_UART_LLD_SetParity( oC_UART_Channel_t Channel , oC_UART_LLD_Parity_t Parity )
625 {
626  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
627 
628  oC_MCS_EnterCriticalSection();
629 
630  if(oC_Module_TurnOnVerification(&errorCode , oC_Module_UART_LLD))
631  {
632  if(
633  ErrorCondition( IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel) &&
634  ErrorCondition( IsChannelPoweredOn(Channel) , oC_ErrorCode_ChannelNotPoweredOn) &&
635  ErrorCondition( AreOperationsDisabled(Channel) , oC_ErrorCode_ChannelOperationsNotDisabled)
636  )
637  {
638  switch(Parity)
639  {
640  case oC_UART_LLD_Parity_None:
641  USARTx_CR1(Channel)->PCE = 0;
642  errorCode = oC_ErrorCode_None;
643  break;
644  case oC_UART_LLD_Parity_Even:
645  USARTx_CR1(Channel)->PCE = 1;
646  USARTx_CR1(Channel)->PS = 0;
647  errorCode = oC_ErrorCode_None;
648  break;
649  case oC_UART_LLD_Parity_Odd:
650  USARTx_CR1(Channel)->PCE = 1;
651  USARTx_CR1(Channel)->PS = 1;
652  errorCode = oC_ErrorCode_None;
653  break;
654  default:
655  errorCode = oC_ErrorCode_ParityNotCorrect;
656  break;
657  }
658  }
659  }
660 
661  oC_MCS_ExitCriticalSection();
662 
663  return errorCode;
664 }
665 
666 //==========================================================================================================================================
671 //==========================================================================================================================================
672 oC_ErrorCode_t oC_UART_LLD_ReadParity( oC_UART_Channel_t Channel , oC_UART_LLD_Parity_t * outParity )
673 {
674  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
675 
676  if(oC_Module_TurnOnVerification(&errorCode , oC_Module_UART_LLD))
677  {
678  if(
679  ErrorCondition( IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel) &&
680  ErrorCondition( IsChannelPoweredOn(Channel) , oC_ErrorCode_ChannelNotPoweredOn) &&
681  ErrorCondition( IsRam(outParity) , oC_ErrorCode_OutputAddressNotInRAM)
682  )
683  {
684  if(USARTx_CR1(Channel)->PCE == 0)
685  {
686  *outParity = oC_UART_LLD_Parity_None;
687  errorCode = oC_ErrorCode_None;
688  }
689  else if(USARTx_CR1(Channel)->PS == 0)
690  {
691  *outParity = oC_UART_LLD_Parity_Even;
692  errorCode = oC_ErrorCode_None;
693  }
694  else if(USARTx_CR1(Channel)->PS == 1)
695  {
696  *outParity = oC_UART_LLD_Parity_Odd;
697  errorCode = oC_ErrorCode_None;
698  }
699  else
700  {
701  errorCode = oC_ErrorCode_MachineCanBeDamaged;
702  }
703  }
704  }
705 
706  return errorCode;
707 }
708 
709 //==========================================================================================================================================
714 //==========================================================================================================================================
715 oC_ErrorCode_t oC_UART_LLD_SetStopBit( oC_UART_Channel_t Channel , oC_UART_LLD_StopBit_t StopBit )
716 {
717  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
718 
719  oC_MCS_EnterCriticalSection();
720 
721  if(oC_Module_TurnOnVerification(&errorCode , oC_Module_UART_LLD))
722  {
723  if(
724  ErrorCondition( IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel) &&
725  ErrorCondition( IsChannelPoweredOn(Channel) , oC_ErrorCode_ChannelNotPoweredOn) &&
726  ErrorCondition( AreOperationsDisabled(Channel) , oC_ErrorCode_ChannelOperationsNotDisabled)
727  )
728  {
729  switch(StopBit)
730  {
731  case oC_UART_LLD_StopBit_0p5Bit:
732  USARTx_CR2(Channel)->STOP = 1;
733  errorCode = oC_ErrorCode_None;
734  break;
735  case oC_UART_LLD_StopBit_1Bit:
736  USARTx_CR2(Channel)->STOP = 0;
737  errorCode = oC_ErrorCode_None;
738  break;
739  case oC_UART_LLD_StopBit_1p5Bits:
740  USARTx_CR2(Channel)->STOP = 3;
741  errorCode = oC_ErrorCode_None;
742  break;
743  case oC_UART_LLD_StopBit_2Bits:
744  USARTx_CR2(Channel)->STOP = 2;
745  errorCode = oC_ErrorCode_None;
746  break;
747  default:
748  errorCode = oC_ErrorCode_StopBitNotSupported;
749  break;
750  }
751  }
752  }
753 
754  oC_MCS_ExitCriticalSection();
755 
756 
757  return errorCode;
758 }
759 
760 //==========================================================================================================================================
765 //==========================================================================================================================================
766 oC_ErrorCode_t oC_UART_LLD_ReadStopBit( oC_UART_Channel_t Channel , oC_UART_LLD_StopBit_t * outStopBit )
767 {
768  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
769 
770  if(oC_Module_TurnOnVerification(&errorCode , oC_Module_UART_LLD))
771  {
772  if(
773  ErrorCondition( IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel) &&
774  ErrorCondition( IsChannelPoweredOn(Channel) , oC_ErrorCode_ChannelNotPoweredOn) &&
775  ErrorCondition( IsRam(outStopBit) , oC_ErrorCode_OutputAddressNotInRAM)
776  )
777  {
778  if(USARTx_CR2(Channel)->STOP == 1)
779  {
780  *outStopBit = oC_UART_LLD_StopBit_0p5Bit;
781  errorCode = oC_ErrorCode_None;
782  }
783  else if(USARTx_CR2(Channel)->STOP == 0)
784  {
785  *outStopBit = oC_UART_LLD_StopBit_1Bit;
786  errorCode = oC_ErrorCode_None;
787  }
788  else if(USARTx_CR2(Channel)->STOP == 3)
789  {
790  *outStopBit = oC_UART_LLD_StopBit_1p5Bits;
791  errorCode = oC_ErrorCode_None;
792  }
793  else if(USARTx_CR2(Channel)->STOP == 2)
794  {
795  *outStopBit = oC_UART_LLD_StopBit_2Bits;
796  errorCode = oC_ErrorCode_None;
797  }
798  else
799  {
800  errorCode = oC_ErrorCode_MachineCanBeDamaged;
801  }
802  }
803  }
804 
805  return errorCode;
806 }
807 
808 //==========================================================================================================================================
813 //==========================================================================================================================================
814 oC_ErrorCode_t oC_UART_LLD_SetBitOrder( oC_UART_Channel_t Channel , oC_UART_LLD_BitOrder_t BitOrder )
815 {
816  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
817 
818  oC_MCS_EnterCriticalSection();
819 
820  if(oC_Module_TurnOnVerification(&errorCode , oC_Module_UART_LLD))
821  {
822  if(
823  ErrorCondition( IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel) &&
824  ErrorCondition( IsChannelPoweredOn(Channel) , oC_ErrorCode_ChannelNotPoweredOn) &&
825  ErrorCondition( AreOperationsDisabled(Channel) , oC_ErrorCode_ChannelOperationsNotDisabled)
826  )
827  {
828  switch(BitOrder)
829  {
830  case oC_UART_LLD_BitOrder_LSBFirst:
831  USARTx_CR2(Channel)->MSBFIRST = 0;
832  errorCode = oC_ErrorCode_None;
833  break;
834  case oC_UART_LLD_BitOrder_MSBFirst:
835  USARTx_CR2(Channel)->MSBFIRST = 1;
836  errorCode = oC_ErrorCode_None;
837  break;
838  default:
839  errorCode = oC_ErrorCode_BitOrderNotSupported;
840  break;
841  }
842  }
843  }
844 
845  oC_MCS_ExitCriticalSection();
846 
847  return errorCode;
848 }
849 
850 //==========================================================================================================================================
855 //==========================================================================================================================================
856 oC_ErrorCode_t oC_UART_LLD_ReadBitOrder( oC_UART_Channel_t Channel , oC_UART_LLD_BitOrder_t * outBitOrder )
857 {
858  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
859 
860  if(oC_Module_TurnOnVerification(&errorCode , oC_Module_UART_LLD))
861  {
862  if(
863  ErrorCondition( IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel) &&
864  ErrorCondition( IsChannelPoweredOn(Channel) , oC_ErrorCode_ChannelNotPoweredOn) &&
865  ErrorCondition( IsRam(outBitOrder) , oC_ErrorCode_OutputAddressNotInRAM)
866  )
867  {
868  if(USARTx_CR2(Channel)->MSBFIRST == 0)
869  {
870  *outBitOrder= oC_UART_LLD_BitOrder_LSBFirst;
871  errorCode = oC_ErrorCode_None;
872  }
873  else if(USARTx_CR2(Channel)->MSBFIRST == 1)
874  {
875  *outBitOrder= oC_UART_LLD_BitOrder_MSBFirst;
876  errorCode = oC_ErrorCode_None;
877  }
878  else
879  {
880  errorCode = oC_ErrorCode_MachineCanBeDamaged;
881  }
882  }
883  }
884 
885  return errorCode;
886 }
887 
888 //==========================================================================================================================================
893 //==========================================================================================================================================
894 oC_ErrorCode_t oC_UART_LLD_SetInvert( oC_UART_Channel_t Channel , oC_UART_LLD_Invert_t Invert )
895 {
896  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
897 
898  oC_MCS_EnterCriticalSection();
899 
900  if(oC_Module_TurnOnVerification(&errorCode , oC_Module_UART_LLD))
901  {
902  if(
903  ErrorCondition( IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel) &&
904  ErrorCondition( IsChannelPoweredOn(Channel) , oC_ErrorCode_ChannelNotPoweredOn) &&
905  ErrorCondition( AreOperationsDisabled(Channel) , oC_ErrorCode_ChannelOperationsNotDisabled)
906  )
907  {
908  if(Invert == oC_UART_LLD_Invert_Inverted)
909  {
910  USARTx_CR2(Channel)->TXINV = 1;
911  USARTx_CR2(Channel)->RXINV = 1;
912  errorCode = oC_ErrorCode_None;
913  }
914  else if(Invert == oC_UART_LLD_Invert_NotInverted)
915  {
916  USARTx_CR2(Channel)->TXINV = 0;
917  USARTx_CR2(Channel)->RXINV = 0;
918  errorCode = oC_ErrorCode_None;
919  }
920  else
921  {
922  errorCode = oC_ErrorCode_InvertNotSupported;
923  }
924  }
925  }
926 
927  oC_MCS_ExitCriticalSection();
928 
929  return errorCode;
930 }
931 
932 //==========================================================================================================================================
937 //==========================================================================================================================================
938 oC_ErrorCode_t oC_UART_LLD_ReadInvert( oC_UART_Channel_t Channel , oC_UART_LLD_Invert_t * outInvert )
939 {
940  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
941 
942  if(oC_Module_TurnOnVerification(&errorCode , oC_Module_UART_LLD))
943  {
944  if(
945  ErrorCondition( IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel) &&
946  ErrorCondition( IsChannelPoweredOn(Channel) , oC_ErrorCode_ChannelNotPoweredOn) &&
947  ErrorCondition( IsRam(outInvert) , oC_ErrorCode_OutputAddressNotInRAM)
948  )
949  {
950  if(USARTx_CR2(Channel)->TXINV == 0 && USARTx_CR2(Channel)->RXINV == 0)
951  {
952  *outInvert = oC_UART_LLD_Invert_NotInverted;
953  errorCode = oC_ErrorCode_None;
954  }
955  else if(USARTx_CR2(Channel)->TXINV == 1 && USARTx_CR2(Channel)->RXINV == 1)
956  {
957  *outInvert = oC_UART_LLD_Invert_Inverted;
958  errorCode = oC_ErrorCode_None;
959  }
960  else
961  {
962  errorCode = oC_ErrorCode_MachineCanBeDamaged;
963  }
964  }
965  }
966 
967  return errorCode;
968 }
969 
970 //==========================================================================================================================================
975 //==========================================================================================================================================
976 oC_ErrorCode_t oC_UART_LLD_SetLoopback( oC_UART_Channel_t Channel , bool Loopback )
977 {
978  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
979 
980  oC_MCS_EnterCriticalSection();
981 
982  if(oC_Module_TurnOnVerification(&errorCode , oC_Module_UART_LLD))
983  {
984  if(
985  ErrorCondition( IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel) &&
986  ErrorCondition( IsChannelPoweredOn(Channel) , oC_ErrorCode_ChannelNotPoweredOn) &&
987  ErrorCondition( AreOperationsDisabled(Channel) , oC_ErrorCode_ChannelOperationsNotDisabled)
988  )
989  {
990  if(!Loopback)
991  {
992  errorCode = oC_ErrorCode_None;
993  }
994  else
995  {
996  errorCode = oC_ErrorCode_LoopbackNotSupported;
997  }
998  }
999  }
1000 
1001  oC_MCS_ExitCriticalSection();
1002 
1003  return errorCode;
1004 }
1005 
1006 //==========================================================================================================================================
1011 //==========================================================================================================================================
1012 oC_ErrorCode_t oC_UART_LLD_ReadLoopback( oC_UART_Channel_t Channel , bool * outLoopback )
1013 {
1014  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
1015 
1016  if(oC_Module_TurnOnVerification(&errorCode , oC_Module_UART_LLD))
1017  {
1018  if(
1019  ErrorCondition( IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel) &&
1020  ErrorCondition( IsChannelPoweredOn(Channel) , oC_ErrorCode_ChannelNotPoweredOn) &&
1021  ErrorCondition( IsRam(outLoopback) , oC_ErrorCode_OutputAddressNotInRAM)
1022  )
1023  {
1024  *outLoopback = false;
1025  errorCode = oC_ErrorCode_None;
1026  }
1027  }
1028 
1029  return errorCode;
1030 }
1031 
1032 //==========================================================================================================================================
1037 //==========================================================================================================================================
1038 oC_ErrorCode_t oC_UART_LLD_ConnectModulePin( oC_UART_Pin_t ModulePin )
1039 {
1040  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
1041 
1042  if(oC_Module_TurnOnVerification(&errorCode , oC_Module_UART_LLD))
1043  {
1044  oC_UART_Channel_t channel = oC_ModulePin_GetChannel(ModulePin);
1045  oC_Pin_t pin = oC_ModulePin_GetPin(ModulePin);
1046 
1047  if(
1048  ErrorCondition( IsChannelCorrect(channel) , oC_ErrorCode_WrongChannel ) &&
1049  ErrorCondition( oC_GPIO_LLD_IsPinDefined(pin) , oC_ErrorCode_PinNotDefined )
1050  )
1051  {
1052  bool unused = false;
1053 
1054  oC_MCS_EnterCriticalSection();
1055 
1056  if(
1057  oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_ArePinsUnused(pin,&unused) ) &&
1058  ErrorCondition( unused , oC_ErrorCode_PinIsUsed ) &&
1059  oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_SetPinsUsed(pin) ) &&
1060  oC_AssignErrorCode(&errorCode , oC_GPIO_MSLLD_ConnectModulePin(ModulePin) )
1061  )
1062  {
1063  errorCode = oC_ErrorCode_None;
1064  }
1065  else
1066  {
1067  oC_GPIO_LLD_SetPinsUnused(pin);
1068  }
1069 
1070  oC_MCS_ExitCriticalSection();
1071  }
1072  }
1073 
1074  return errorCode;
1075 }
1076 
1077 //==========================================================================================================================================
1082 //==========================================================================================================================================
1083 oC_ErrorCode_t oC_UART_LLD_DisconnectModulePin( oC_UART_Pin_t ModulePin )
1084 {
1085  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
1086 
1087  if(oC_Module_TurnOnVerification(&errorCode , oC_Module_UART_LLD))
1088  {
1089  oC_UART_Channel_t channel = oC_ModulePin_GetChannel(ModulePin);
1090  oC_Pin_t pin = oC_ModulePin_GetPin(ModulePin);
1091 
1092  if(
1093  ErrorCondition( IsChannelCorrect(channel) , oC_ErrorCode_WrongChannel ) &&
1094  ErrorCondition( oC_GPIO_LLD_IsPinDefined(pin) , oC_ErrorCode_PinNotDefined )
1095  )
1096  {
1097  oC_MCS_EnterCriticalSection();
1098 
1099  if(
1100  oC_AssignErrorCode(&errorCode , oC_GPIO_LLD_SetPinsUnused(pin) ) &&
1101  oC_AssignErrorCode(&errorCode , oC_GPIO_MSLLD_DisconnectModulePin(ModulePin) )
1102  )
1103  {
1104  errorCode = oC_ErrorCode_None;
1105  }
1106 
1107  oC_MCS_ExitCriticalSection();
1108  }
1109  }
1110 
1111  return errorCode;
1112 }
1113 
1114 //==========================================================================================================================================
1119 //==========================================================================================================================================
1120 oC_ErrorCode_t oC_UART_LLD_SetChannelUsed( oC_UART_Channel_t Channel )
1121 {
1122  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
1123 
1124  if(oC_Module_TurnOnVerification(&errorCode , oC_Module_UART_LLD))
1125  {
1126  oC_MCS_EnterCriticalSection();
1127 
1128  if( ErrorCondition(IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel) )
1129  {
1130  UsedChannels |= (1<<oC_Channel_ToIndex(UART,Channel));
1131  errorCode = oC_ErrorCode_None;
1132  }
1133 
1134  oC_MCS_ExitCriticalSection();
1135  }
1136 
1137  return errorCode;
1138 }
1139 
1140 //==========================================================================================================================================
1145 //==========================================================================================================================================
1146 oC_ErrorCode_t oC_UART_LLD_SetChannelUnused( oC_UART_Channel_t Channel )
1147 {
1148  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
1149 
1150  if(oC_Module_TurnOnVerification(&errorCode , oC_Module_UART_LLD))
1151  {
1152  oC_MCS_EnterCriticalSection();
1153 
1154  if( ErrorCondition(IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel) )
1155  {
1156  UsedChannels &= ~(1<<oC_Channel_ToIndex(UART,Channel));
1157  errorCode = oC_ErrorCode_None;
1158  }
1159 
1160  oC_MCS_ExitCriticalSection();
1161  }
1162 
1163  return errorCode;
1164 }
1165 
1166 //==========================================================================================================================================
1171 //==========================================================================================================================================
1172 bool oC_UART_LLD_IsChannelUsed( oC_UART_Channel_t Channel )
1173 {
1174  bool used = false;
1175 
1176  if(oC_Module_IsTurnedOn(oC_Module_UART_LLD))
1177  {
1178  if(IsChannelCorrect(Channel))
1179  {
1180  used = (UsedChannels & (1<<oC_Channel_ToIndex(UART,Channel))) == (1<<oC_Channel_ToIndex(UART,Channel));
1181  }
1182  }
1183 
1184  return used;
1185 }
1186 
1187 //==========================================================================================================================================
1192 //==========================================================================================================================================
1193 oC_ErrorCode_t oC_UART_LLD_ReadModulePinsOfPin( oC_Pin_t Pin , oC_UART_Pin_t * outModulePinsArray , uint32_t * ArraySize , oC_UART_PinFunction_t PinFunction )
1194 {
1195  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
1196 
1197  if(oC_Module_TurnOnVerification(&errorCode , oC_Module_UART_LLD))
1198  {
1199 
1200  if(
1201  ErrorCondition( oC_GPIO_LLD_IsPinDefined(Pin) , oC_ErrorCode_PinNotDefined) &&
1202  ErrorCondition( IsRam(ArraySize) , oC_ErrorCode_OutputAddressNotInRAM) &&
1203  ErrorCondition(outModulePinsArray == NULL || IsRam(outModulePinsArray) , oC_ErrorCode_OutputAddressNotInRAM)
1204  )
1205  {
1206  uint32_t foundPins = 0;
1207 
1208  errorCode = oC_ErrorCode_None;
1209 
1210  oC_ModulePin_ForeachDefined(modulePin)
1211  {
1212  if(modulePin->Pin == Pin && oC_Channel_IsCorrect(UART,modulePin->Channel) && modulePin->PinFunction == PinFunction)
1213  {
1214  if(outModulePinsArray != NULL)
1215  {
1216  if(foundPins < *ArraySize)
1217  {
1218  outModulePinsArray[foundPins] = modulePin->ModulePinIndex;
1219  }
1220  else
1221  {
1222  errorCode = oC_ErrorCode_OutputArrayToSmall;
1223  }
1224  }
1225  foundPins++;
1226  }
1227  }
1228 
1229  *ArraySize = foundPins;
1230  }
1231  }
1232 
1233  return errorCode;
1234 }
1235 
1236 //==========================================================================================================================================
1237 //==========================================================================================================================================
1238 oC_ErrorCode_t oC_UART_LLD_ClearRxFifo( oC_UART_Channel_t Channel )
1239 {
1240  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
1241 
1242  if(ErrorCondition(oC_Channel_IsCorrect(UART,Channel) , oC_ErrorCode_WrongChannel ))
1243  {
1244  ClearSoftwareRing(&RxRing(Channel));
1245  errorCode = oC_ErrorCode_None;
1246  }
1247 
1248  return errorCode;
1249 }
1250 
1251 //==========================================================================================================================================
1256 //==========================================================================================================================================
1257 bool oC_UART_LLD_IsTxFifoFull( oC_UART_Channel_t Channel )
1258 {
1259 #if USE_INTERRUPTS_FOR_TX
1260  return IsSoftwareTxRingFull(Channel);
1261 #else
1262  return false;
1263 #endif
1264 }
1265 
1266 //==========================================================================================================================================
1271 //==========================================================================================================================================
1272 bool oC_UART_LLD_IsRxFifoEmpty( oC_UART_Channel_t Channel )
1273 {
1274  return IsSoftwareRxRingEmpty(Channel);
1275 }
1276 
1277 //==========================================================================================================================================
1282 //==========================================================================================================================================
1283 void oC_UART_LLD_PutData( oC_UART_Channel_t Channel , char Data )
1284 {
1285 #if USE_INTERRUPTS_FOR_TX
1286  oC_MCS_EnterCriticalSection();
1287  USARTx_CR1(Channel)->TCIE = 1;
1288 
1289  if(IsSoftwareTxRingEmpty(Channel) && TransmitDataMovedToFifo(Channel))
1290  {
1291  USARTx_TDR(Channel)->TDR = Data;
1292  }
1293  else
1294  {
1295  PutToSoftwareRing(&TxRing(Channel),Data);
1296  }
1297  oC_MCS_ExitCriticalSection();
1298 #else
1299  while(TransmitDataMovedToFifo(Channel) != true);
1300  USARTx_TDR(Channel)->TDR = Data;
1301 #endif
1302 }
1303 
1304 //==========================================================================================================================================
1309 //==========================================================================================================================================
1310 char oC_UART_LLD_GetData( oC_UART_Channel_t Channel )
1311 {
1312  return (char)GetFromSoftwareRing(&RxRing(Channel));
1313 }
1314 
1315 //==========================================================================================================================================
1320 //==========================================================================================================================================
1321 oC_ErrorCode_t oC_UART_LLD_WriteWithDma( oC_UART_Channel_t Channel , const char * Buffer , oC_UInt_t Size )
1322 {
1323  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
1324 
1325  if(oC_Module_TurnOnVerification(&errorCode , oC_Module_UART_LLD))
1326  {
1327  if(
1328  ErrorCondition( IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel) &&
1329  ErrorCondition( IsRam(Buffer) || IsRom(Buffer) , oC_ErrorCode_WrongAddress) &&
1330  ErrorCondition( Size > 0 , oC_ErrorCode_SizeNotCorrect) &&
1331  ErrorCondition( IsChannelPoweredOn(Channel) , oC_ErrorCode_ChannelNotPoweredOn) &&
1332  ErrorCondition( AreOperationsEnabled(Channel) , oC_ErrorCode_ChannelOperationsNotEnabled)
1333  )
1334  {
1335  errorCode = oC_ErrorCode_NotImplemented;
1336  }
1337  }
1338 
1339  return errorCode;
1340 }
1341 
1342 //==========================================================================================================================================
1347 //==========================================================================================================================================
1348 oC_ErrorCode_t oC_UART_LLD_ReadWithDma( oC_UART_Channel_t Channel , char * outBuffer , oC_UInt_t Size )
1349 {
1350  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
1351 
1352  if(oC_Module_TurnOnVerification(&errorCode , oC_Module_UART_LLD))
1353  {
1354  if(
1355  ErrorCondition( IsChannelCorrect(Channel) , oC_ErrorCode_WrongChannel) &&
1356  ErrorCondition( IsRam(outBuffer) , oC_ErrorCode_OutputAddressNotInRAM) &&
1357  ErrorCondition( Size > 0 , oC_ErrorCode_SizeNotCorrect) &&
1358  ErrorCondition( IsChannelPoweredOn(Channel) , oC_ErrorCode_ChannelNotPoweredOn) &&
1359  ErrorCondition( AreOperationsEnabled(Channel) , oC_ErrorCode_ChannelOperationsNotEnabled)
1360  )
1361  {
1362  errorCode = oC_ErrorCode_NotImplemented;
1363  }
1364  }
1365 
1366  return errorCode;
1367 }
1368 
1369 #undef _________________________________________FUNCTIONS_SECTION__________________________________________________________________________
1370 
1376 #define _________________________________________LOCAL_FUNCTIONS_SECTION____________________________________________________________________
1377 
1378 //==========================================================================================================================================
1382 //==========================================================================================================================================
1383 static inline void PutToSoftwareRing( SoftwareRing_t * Ring , uint16_t Data )
1384 {
1385  if(Ring->Counter >= SOFTWARE_RING_COUNT)
1386  {
1387  /* If ring is full, take the oldest data */
1388  GetFromSoftwareRing(Ring);
1389  }
1390 
1391  Ring->Buffer[Ring->PutIndex++] = Data;
1392  Ring->Counter++;
1393 
1394  if(Ring->PutIndex >= SOFTWARE_RING_COUNT)
1395  {
1396  Ring->PutIndex = 0;
1397  }
1398 }
1399 
1400 //==========================================================================================================================================
1404 //==========================================================================================================================================
1405 static inline uint16_t GetFromSoftwareRing( SoftwareRing_t * Ring )
1406 {
1407  uint16_t data = 0xFFFF;
1408 
1409  if(Ring->Counter > 0)
1410  {
1411  Ring->Counter--;
1412  data = Ring->Buffer[Ring->GetIndex++];
1413  if(Ring->GetIndex >= SOFTWARE_RING_COUNT)
1414  {
1415  Ring->GetIndex = 0;
1416  }
1417  }
1418 
1419  return data;
1420 }
1421 
1422 //==========================================================================================================================================
1426 //==========================================================================================================================================
1427 static inline void ClearSoftwareRing( SoftwareRing_t * Ring )
1428 {
1429  memset(Ring,0,sizeof(SoftwareRing_t));
1430 }
1431 
1432 #undef _________________________________________LOCAL_FUNCTIONS_SECTION____________________________________________________________________
1433 
1434 
1440 #define _________________________________________INTERRUPTS_SECTION_________________________________________________________________________
1441 
1442 #define MODULE_NAME UART
1443 #define INTERRUPT_TYPE_NAME PeripheralInterrupt
1444 
1445 //==========================================================================================================================================
1449 //==========================================================================================================================================
1450 oC_Channel_InterruptHandler(Channel)
1451 {
1452  if(USARTx_ISR(Channel)->TC == 1)
1453  {
1454  while(IsSoftwareTxRingEmpty(Channel) == false && (TransmitDataMovedToFifo(Channel)))
1455  {
1456  USARTx_TDR(Channel)->TDR = GetFromSoftwareRing(&TxRing(Channel));
1457  }
1458 
1459  if(TxNotFullHandler)
1460  {
1461  TxNotFullHandler(Channel);
1462  }
1463 
1464  if(IsSoftwareTxRingEmpty(Channel))
1465  {
1466  USARTx_CR1(Channel)->TCIE = 0;
1467  }
1468  }
1469 
1470  if(USARTx_ISR(Channel)->RXNE == 1)
1471  {
1472  while(ReceiveDataAvailable(Channel))
1473  {
1474  PutToSoftwareRing(&RxRing(Channel),USARTx_RDR(Channel)->RDR);
1475  }
1476 
1477  if(RxNotEmptyHandler)
1478  {
1479  RxNotEmptyHandler(Channel);
1480  }
1481  }
1482 
1483  USARTx_ICR(Channel)->Value = 0x21B5F;
1484 }
1485 
1486 #undef _________________________________________INTERRUPTS_SECTION_________________________________________________________________________
1487 
oC_Power_On
Something is powered on.
Definition: oc_stdtypes.h:252
oC_Frequency_t
double oC_Frequency_t
type to store frequency
Definition: oc_frequency.h:76
oc_compiler.h
The file contains definitions for the compiler, that helps to manage errors, etc. ...
oc_lsf.h
The file with interface for LSF module.
SoftwareRing_t
Definition: oc_netifman.c:69
oc_mem_lld.h
The file with LLD interface for the MEM driver.
oc_module.h
The file with interface for the module library.
oC_CLOCK_LLD_GetClockFrequency
oC_Frequency_t oC_CLOCK_LLD_GetClockFrequency(void)
returns frequency of the system clock
Definition: oc_clock_lld.c:237
oC_Module_IsTurnedOn
static bool oC_Module_IsTurnedOn(oC_Module_t Module)
checks if the module is turned on
Definition: oc_module.h:121
oC_Power_Off
Something is powered off.
Definition: oc_stdtypes.h:251
oc_clock_lld.h
The file with LLD interface for the CLOCK driver.
oC_Channel_t
oC_Channel_t
stores machine channel
Definition: oc_channels.h:573
oC_Channel_IsCorrect
#define oC_Channel_IsCorrect(MODULE_NAME, Channel)
checks if channel is correct
Definition: oc_channels.h:283
oC_Channel_FromIndex
#define oC_Channel_FromIndex(MODULE_NAME, ChannelIndex)
returns channel according to index in module
Definition: oc_channels.h:313
oC_ModuleChannel_NumberOfElements
#define oC_ModuleChannel_NumberOfElements(MODULE_NAME)
Number of elements in module channel.
Definition: oc_channels.h:465
oC_Module_TurnOn
static void oC_Module_TurnOn(oC_Module_t Module)
sets module as turned on
Definition: oc_module.h:170
oc_bits.h
The file with functions for the bits operation.
oC_MCS_EnterCriticalSection
static void oC_MCS_EnterCriticalSection(void)
Enters to critical section.
Definition: oc_mcs.h:755
oc_array.h
Static array definitions.
PutToSoftwareRing
static void PutToSoftwareRing(SoftwareRing_t *SoftwareRing, oC_Netif_t Netif, oC_Net_Packet_t *Packet)
puts packet to the software ring
Definition: oc_netifman.c:951
oC_Machine_GetPowerStateForChannel
static oC_Power_t oC_Machine_GetPowerStateForChannel(oC_Channel_t Channel)
returns power state for channel
Definition: oc_machine.h:550
oC_Module_TurnOffVerification
static bool oC_Module_TurnOffVerification(oC_ErrorCode_t *outErrorCode, oC_Module_t Module)
verify if module is turned off
Definition: oc_module.h:155
oC_MCS_ExitCriticalSection
static bool oC_MCS_ExitCriticalSection(void)
Exits from critical section.
Definition: oc_mcs.h:784
oC_Module_TurnOnVerification
static bool oC_Module_TurnOnVerification(oC_ErrorCode_t *outErrorCode, oC_Module_t Module)
verify if module is turned on
Definition: oc_module.h:138
oC_Channel_ToIndex
#define oC_Channel_ToIndex(MODULE_NAME, Channel)
returns index in module according to channel
Definition: oc_channels.h:298
oc_dma_lld.h
The file with LLD interface for the DMA driver.
GetFromSoftwareRing
static bool GetFromSoftwareRing(SoftwareRing_t *SoftwareRing, const oC_Net_Address_t *Address, oC_Net_Packet_t *outPacket, oC_Netif_t *outNetif, oC_NetifMan_PacketFilterFunction_t FilterFunction, const void *Parameter)
reads packet from the software ring
Definition: oc_netifman.c:987
oC_Channel_InterruptHandler
#define oC_Channel_InterruptHandler(ChannelVariableName)
creates common interrupt handler for channel
Definition: oc_channels.h:514
oC_Machine_SetPowerStateForChannel
static bool oC_Machine_SetPowerStateForChannel(oC_Channel_t Channel, oC_Power_t Power)
configures power state for machine channel
Definition: oc_machine.h:593
oc_stdtypes.h
FILE__DESCRIPTION
oC_Power_t
oC_Power_t
stores registers power state
Definition: oc_stdtypes.h:249
oC_InterruptPriority_Maximum
The most important interrupt priority, that is possible in the machine.
Definition: oc_mcs.h:178
NULL
#define NULL
pointer to a zero
Definition: oc_null.h:37
oC_Module_TurnOff
static void oC_Module_TurnOff(oC_Module_t Module)
sets module as turned off
Definition: oc_module.h:185