TMS320F28335 Library  1.0
Documentation
Functions
can.c File Reference

Source code file for CAN module. More...

Go to the source code of this file.

Functions

TMPS_CAN CAN_getInterface (Uint16 gpio)
 get_can_interface for matching right CANInterfaces. More...
 
int16 init_CAN (CanInterface CAN_Int, Uint32 baudrate)
 Initializes a CAN interface with the passed baud rate. More...
 
void CAN_setupMailbox (CanInterface CAN_Int, Uint16 mb_number, CanMailbox *mailbox)
 CAN_setup_Mailbox - Configures Register for a CAN mailbox. More...
 
int16 CAN_sendDataOnMailbox (CanInterface CAN_Int, Uint16 mb_number, Uint64 *data, Uint16 length)
 CAN_send - Sends a CAN message. More...
 
int16 CAN_dataAvailable (CanInterface CAN_Int)
 Checks if a CAN message is available in the passed CAN interface. More...
 
int16 CAN_dataAvailableAtMailbox (CanInterface CAN_Int, Uint16 mb_number)
 Checks if a CAN message is available in the passed CAN mailbox. More...
 
void CAN_getDataFromMailbox (CanInterface CAN_Int, Uint16 mb_number, Uint64 *data, Uint16 length)
 Gets the content of a received CAN message on specific mailbox and writes it to data-address. More...
 
void CAN_resetMailbox (CanInterface CAN_Int, Uint16 mb_number)
 Erases the "new message" bit for the passed mailbox. More...
 
int CAN_mailboxActive (CanInterface CAN_Int, Uint16 mb_number)
 Checks if the passed mailbox is in use already (active). More...
 
int CAN_getNextInactiveMailbox (CanInterface CAN_Int)
 Get the lowest inactive mailbox from a CAN interface (0-31). More...
 
void CAN_getMailboxInformation (CanInterface CAN_Int, Uint16 mb_number, CanMailbox *data)
 Gets mailbox information. More...
 

Detailed Description

Source code file for CAN module.

Definition in file can.c.

Function Documentation

◆ CAN_dataAvailable()

int16 CAN_dataAvailable ( CanInterface  CAN_Int)

Checks if a CAN message is available in the passed CAN interface.

Parameters
[in]1) CAN_Interface
Returns
data available
--> 0 = no message available
--> 1 = message available

Definition at line 405 of file can.c.

405  {
406  TMPS_CAN CAN = CAN_getInterface(CAN_Int.canrx);
407 
408  return CAN->RMP?1:0;
409 }

◆ CAN_dataAvailableAtMailbox()

int16 CAN_dataAvailableAtMailbox ( CanInterface  CAN_Int,
Uint16  mb_number 
)

Checks if a CAN message is available in the passed CAN mailbox.

Parameters
[in]1) CAN_Interface
2) mailbox number
Returns
data available
--> 0 = no
--> 1 = yes

Definition at line 419 of file can.c.

419  {
420  TMPS_CAN CAN = CAN_getInterface(CAN_Int.canrx);
421 
422  return CAN->RMP&(1<<mb_number)?1:0;
423 }

◆ CAN_getDataFromMailbox()

void CAN_getDataFromMailbox ( CanInterface  CAN_Int,
Uint16  mb_number,
Uint64 *  data,
Uint16  length 
)

Gets the content of a received CAN message on specific mailbox and writes it to data-address.

Parameters
[in]1) CANInterface
2) mailbox number
3) Pointer to data
4) length of data to be read in byte
Returns
/

Definition at line 435 of file can.c.

435  { //Funktion zum Auslesen von Mailbox DATEN
436  TMPS_CAN CAN = CAN_getInterface(CAN_Int.canrx);
437 
438  if(length<4){
439  *data |= CAN->MO[mb_number].MDL;
440  }
441  else{
442  *data |= CAN->MO[mb_number].MDL;
443  *data |= ((Uint64)CAN->MO[mb_number].MDH<<32);
444  }
445 
446  CAN->RMP |= (1<<mb_number);
447 }

◆ CAN_getInterface()

TMPS_CAN CAN_getInterface ( Uint16  gpio)

get_can_interface for matching right CANInterfaces.

Parameters
[in]1) gpio (cantx of CANInterface)
Returns
Pointer to the CAN interface the gpio is part of (TMPS_CAN)
--> 0x6000 = TMC_BASE_CANA
--> 0x6200 = TMC_BASE_CANB

Definition at line 523 of file can.c.

523  {
524  TMPS_CAN CAN;
525  switch(gpio){
526  case 8: CAN = TMC_BASE_CANB;
527  break;
528  case 10: CAN = TMC_BASE_CANB;
529  break;
530  case 12: CAN = TMC_BASE_CANB;
531  break;
532  case 13: CAN = TMC_BASE_CANB;
533  break;
534  case 16: CAN = TMC_BASE_CANB;
535  break;
536  case 17: CAN = TMC_BASE_CANB;
537  break;
538  case 18: CAN = TMC_BASE_CANA;
539  break;
540  case 19: CAN = TMC_BASE_CANA;
541  break;
542  case 20: CAN = TMC_BASE_CANB;
543  break;
544  case 21: CAN = TMC_BASE_CANB;
545  break;
546  case 30: CAN = TMC_BASE_CANA;
547  break;
548  case 31: CAN = TMC_BASE_CANA;
549  break;
550  default: break;
551  }
552  return CAN;
553 }

◆ CAN_getMailboxInformation()

void CAN_getMailboxInformation ( CanInterface  CAN_Int,
Uint16  mb_number,
CanMailbox *  data 
)

Gets mailbox information.

Parameters
[in]1) CAN interface that is used
2) Number of the mailbox of which the information is needed, from 0 to 31
3) Pointer to a CAN mailbox where the mailbox data is to be stored (CanMailbox*)
Returns
/

Definition at line 501 of file can.c.

501  {
502  TMPS_CAN CAN = CAN_getInterface(CAN_Int.canrx);
503 
504  if(CAN->MO[mb_number].ID>>31 != 0) {
505  data->Message_ID = CAN->MO[mb_number].ID&0x1FFFFFFF;
506  data->extended = 1;
507  } else {
508  data->Message_ID = (CAN->MO[mb_number].ID>>18)&0x7FF;
509  data->extended = 0;
510  }
511  data->messageLength = CAN->MO[mb_number].CTRL&0x0F;
512  data->direction = (CAN_direction)(CAN->MD&(1UL<<mb_number));
513  data->active = CAN->ME&(1UL<<mb_number)?1:0;
514 }

◆ CAN_getNextInactiveMailbox()

int CAN_getNextInactiveMailbox ( CanInterface  CAN_Int)

Get the lowest inactive mailbox from a CAN interface (0-31).

Parameters
[in]1) CAN_Interface
Returns
first inactive mailbox
--> 0-31 = Number of the first free mailbox in the passed interface
--> -1 = all mailboxes in use

Definition at line 481 of file can.c.

481  {
482  TMPS_CAN CAN = CAN_getInterface(CAN_Int.canrx);
483 
484  int i;
485  for(i=0; i<32; i++) {
486  if(!(CAN->ME & (1UL<<i))) {
487  return i;
488  }
489  }
490  return -1;
491 
492 }

◆ CAN_mailboxActive()

int CAN_mailboxActive ( CanInterface  CAN_Int,
Uint16  mb_number 
)

Checks if the passed mailbox is in use already (active).

Parameters
[in]1) CAN_Interface
2) mailbox number
Returns
status
--> 0 = mailbox inactive
--> 1 = mailbox active

Definition at line 469 of file can.c.

469  {
470  TMPS_CAN CAN = CAN_getInterface(CAN_Int.canrx);
471  return (CAN->ME & (1UL<<mb_number))?1:0;
472 }

◆ CAN_resetMailbox()

void CAN_resetMailbox ( CanInterface  CAN_Int,
Uint16  mb_number 
)

Erases the "new message" bit for the passed mailbox.

Parameters
[in]1) CAN_Interface
2) Number of the mailbox that shall be reset
Returns
/

Definition at line 455 of file can.c.

455  { //Funktion zum Löschen des "neue Nachricht" bit
456  TMPS_CAN CAN = CAN_getInterface(CAN_Int.canrx);
457 
458  CAN->RMP |= (1<<mb_number);
459 }

◆ CAN_sendDataOnMailbox()

int16 CAN_sendDataOnMailbox ( CanInterface  CAN_Int,
Uint16  mb_number,
Uint64 *  data,
Uint16  length 
)

CAN_send - Sends a CAN message.

Parameters
[in]1) CAN_Interface
2) Number of the mailbox where the message should be sent from, from 0 to 31
3) Pointer to the content of the CAN message (max. 8 Byte)
4) Length of the CAN message to be sent in bytes (defines how much dataybtes are sent)
Returns
Result of operations as int16
--> 0 = operation successful
--> -21 = datalength too low
--> -22 = Mailbox not configured as Tx-Mailbox

Definition at line 370 of file can.c.

370  {
371  TMPS_CAN CAN = CAN_getInterface(CAN_Int.canrx);
372 
373  if(length>8){
374  return -21;
375  }
376  if(CAN->MD & ((Uint32)0x1<<mb_number)){
377  return -22;
378  }
379 
380  CAN->MO[mb_number].MDL = 0;
381  CAN->MO[mb_number].MDH = 0;
382 
383  if(length<4) {
384  CAN->MO[mb_number].MDL |= (*data&0xFFFFFFFF);
385  } else {
386  CAN->MO[mb_number].MDL |= (*data&0xFFFFFFFF);
387  CAN->MO[mb_number].MDH |= (*data>>32)&0xFFFFFFFF;
388  }
389 
390  if(CAN->TA & ((Uint32)0x1<<mb_number)){
391  CAN->TA |= ((Uint32)0x1<<mb_number);
392  }
393 
394  CAN->TRS = ((Uint32)0x1<<mb_number); // Send Mailbox
395  return 0;
396 }

◆ CAN_setupMailbox()

void CAN_setupMailbox ( CanInterface  CAN_Int,
Uint16  mb_number,
CanMailbox *  mailbox 
)

CAN_setup_Mailbox - Configures Register for a CAN mailbox.

Parameters
[in]1) CAN_Interface
2) mailbox number
3) CanMailbox *mailbox
Returns
/

Definition at line 321 of file can.c.

321  {
322  TMPS_CAN CAN = CAN_getInterface(CAN_Int.canrx);
323 
324  Uint32 temp;
325  Uint32 temp1;
326  Uint32 temp2;
327  if(mailbox->extended) {
328  temp = ((Uint32)mailbox->Message_ID) | ((Uint32)0x1<<31);
329  } else {
330  temp = ((Uint32)mailbox->Message_ID<<18); //MSGID is stored in in bits 28:18.
331  }
332 
333  // Write Id-Register only when change is pending
334  if(CAN->MO[mb_number].ID != temp) {
335  temp1 = CAN->ME;
336  CAN->ME &= ~((Uint32)0x1<<mb_number); // Set off mailbox for Id change
337  CAN->MO[mb_number].ID = temp; // Write Id-register
338  }
339 
340  CAN->MO[mb_number].CTRL = (CAN->MO[mb_number].CTRL &= ~0x0F ) | mailbox->messageLength;
341 
342  if(mailbox->direction == CAN_Rx) {
343  temp2 = CAN->MD;
344  temp2 |= (1UL<<mb_number);
345  CAN->MD = temp2; // Mailbox Direction
346  } else if (mailbox->direction == CAN_Tx) {
347  CAN->MD &= ~((Uint32)0x1<<mb_number); // Mailbox Direction
348  }
349 
350  if(mailbox->active) {
351  temp1 |= (Uint32)(CAN->ME | (1<<mb_number));
352  CAN->ME = temp1; // Activate Mailbox
353  } else {
354  CAN->ME &= ~((Uint32)0x1<<mb_number); // Deactivate Mailbox
355  }
356 }

◆ init_CAN()

int16 init_CAN ( CanInterface  CAN_Int,
Uint32  baudrate 
)

Initializes a CAN interface with the passed baud rate.

Parameters
[in]1) CanInterface
2) baud rate
Returns
Result of operations as int16
--> 0 = operation successful
--> -1 = invalid value of canrx
--> -2 = invalid value of cantx
--> -8 = not able to set baudrate, baudrate too low
--> -9 = Baudrate too high 1Mbit/s
--> -10 = CAN-Module already in use
--> -11 = Tseg1 < Tseg2; Tseg1 needs to be >= Tseg2
--> -12 = Tseg1: maximal 16Tq
--> -13 = Tseg2: maximal 8Tq
--> -14 = Tseg1: minimal 2Tq
--> -15 = Tseg2: minimal 1Tq

Definition at line 31 of file can.c.

31  {
32  TMPS_CAN CAN = CAN_getInterface(CAN_Int.cantx); // Call function to assign correct address-value to variable for register-access
33  static int CAN_A_in_use=0;
34  static int CAN_B_in_use=0;
35  int i=0;
36 
37  EALLOW;
38  switch(CAN_Int.canrx){
39  case 10: if(!CAN_B_in_use){
40  TMC_BASE_PIO->CTL[0].PUD &= ~(0x1 << CAN_Int.canrx); // Enable pull-up for GPIO(CANRXB)
41  TMC_BASE_PIO->CTL[0].QSEL1 |= ((Uint32)0x3 << 20); // Asynch qual for GPIO10 (CANRXB)
42  TMC_BASE_PIO->CTL[0].MUX1 |= ((Uint32)0x2 << 20); // Configure GPIO10 for CANRXB
43  switch(CAN_Int.cantx){
44  case 8: TMC_BASE_PIO->CTL[0].PUD &= ~(0x1 << CAN_Int.cantx); // Enable pull-up for GPIO8 (CANTXB)
45  TMC_BASE_PIO->CTL[0].MUX1 |= ((Uint32)0x2 << 16); // Configure GPIO8 for CANTXB
46  break;
47  case 12: TMC_BASE_PIO->CTL[0].PUD &= ~(0x1 << CAN_Int.cantx); // Enable pull-up for GPIO (CANTXB)
48  TMC_BASE_PIO->CTL[0].MUX1 |= ((Uint32)0x2 << 24); // Configure GPIO for CANTXB
49  break;
50  case 16: TMC_BASE_PIO->CTL[0].PUD &= ~(0x1 << CAN_Int.cantx); // Enable pull-up for GPIO (CANTXB)
51  TMC_BASE_PIO->CTL[0].MUX2 |= (0x2); // Configure GPIO for CANTXB
52  break;
53  case 20: TMC_BASE_PIO->CTL[0].PUD &= ~(0x1 << CAN_Int.cantx); // Enable pull-up for GPIO (CANTXB)
54  TMC_BASE_PIO->CTL[0].MUX2 |= (0x3 << 8); // Configure GPIO for CANTXB
55  break;
56  default: EDIS;
57  return -2;
58  }
59  CAN_B_in_use=1;
60  }
61  else{
62  return -10;
63  }
64  break;
65  case 13: if(!CAN_B_in_use){
66  TMC_BASE_PIO->CTL[0].PUD &= ~(0x1 << CAN_Int.canrx); // Enable pull-up for GPIO(CANRXB)
67  TMC_BASE_PIO->CTL[0].QSEL1 |= (0x3 << (CAN_Int.canrx*2)); // Asynch qual for GPIO (CANRXB)
68  TMC_BASE_PIO->CTL[0].MUX1 |= ((Uint32)0x2 << 26); // Configure GPIO for CANRXB
69  switch(CAN_Int.cantx){
70  case 8: TMC_BASE_PIO->CTL[0].PUD &= ~(0x1 << CAN_Int.cantx); // Enable pull-up for GPIO8 (CANTXB)
71  TMC_BASE_PIO->CTL[0].MUX1 |= ((Uint32)0x2 << 16); // Configure GPIO8 for CANTXB
72  break;
73  case 12: TMC_BASE_PIO->CTL[0].PUD &= ~(0x1 << CAN_Int.cantx); // Enable pull-up for GPIO (CANTXB)
74  TMC_BASE_PIO->CTL[0].MUX1 |= ((Uint32)0x2 << 24); // Configure GPIO for CANTXB
75  break;
76  case 16: TMC_BASE_PIO->CTL[0].PUD &= ~(0x1 << CAN_Int.cantx); // Enable pull-up for GPIO (CANTXB)
77  TMC_BASE_PIO->CTL[0].MUX2 |= (0x2); // Configure GPIO for CANTXB
78  break;
79  case 20: TMC_BASE_PIO->CTL[0].PUD &= ~(0x1 << CAN_Int.cantx); // Enable pull-up for GPIO (CANTXB)
80  TMC_BASE_PIO->CTL[0].MUX2 |= (0x3 << 8); // Configure GPIO for CANTXB
81  break;
82  default: EDIS;
83  return -2;
84  }
85  CAN_B_in_use=1;
86  }
87  else{
88  return -10;
89  }
90  break;
91  case 17: if(!CAN_B_in_use){
92  TMC_BASE_PIO->CTL[0].PUD &= ~(0x1 << CAN_Int.canrx); // Enable pull-up for GPIO(CANRXB)
93  TMC_BASE_PIO->CTL[0].QSEL2 |= (0x3 << 2); // Asynch qual for GPIO (CANRXB)
94  TMC_BASE_PIO->CTL[0].MUX2 |= (0x2 << 2); // Configure GPIO for CANRXB
95  switch(CAN_Int.cantx){
96  case 8: TMC_BASE_PIO->CTL[0].PUD &= ~(0x1 << CAN_Int.cantx); // Enable pull-up for GPIO8 (CANTXB)
97  TMC_BASE_PIO->CTL[0].MUX1 |= ((Uint32)0x2 << 16); // Configure GPIO8 for CANTXB
98  break;
99  case 12: TMC_BASE_PIO->CTL[0].PUD &= ~(0x1 << CAN_Int.cantx); // Enable pull-up for GPIO (CANTXB)
100  TMC_BASE_PIO->CTL[0].MUX1 |= ((Uint32)0x2 << 24); // Configure GPIO for CANTXB
101  break;
102  case 16: TMC_BASE_PIO->CTL[0].PUD &= ~(0x1 << CAN_Int.cantx); // Enable pull-up for GPIO (CANTXB)
103  TMC_BASE_PIO->CTL[0].MUX2 |= (0x2); // Configure GPIO for CANTXB
104  break;
105  case 20: TMC_BASE_PIO->CTL[0].PUD &= ~(0x1 << CAN_Int.cantx); // Enable pull-up for GPIO (CANTXB)
106  TMC_BASE_PIO->CTL[0].MUX2 |= (0x3 << 8); // Configure GPIO for CANTXB
107  break;
108  default: EDIS;
109  return -2;
110  }
111  CAN_B_in_use=1;
112  }
113  else{
114  return -10;
115  }
116  break;
117  case 18: if(!CAN_A_in_use){
118  TMC_BASE_PIO->CTL[0].PUD &= ~(0x1 << CAN_Int.canrx); // Enable pull-up for GPIO(CANRXA)
119  TMC_BASE_PIO->CTL[0].QSEL2 |= (0x3 << 4); // Asynch qual for GPIO (CANRXA)
120  TMC_BASE_PIO->CTL[0].MUX2 |= (0x3 << 4); // Configure GPIO for CANRXA
121  switch(CAN_Int.cantx){
122  case 19: TMC_BASE_PIO->CTL[0].PUD &= ~(0x1 << CAN_Int.cantx); // Enable pull-up for GPIO (CANTXA)
123  TMC_BASE_PIO->CTL[0].MUX2 |= (0x3 << 6); // Configure GPIO for CANTXA
124  break;
125  case 31: TMC_BASE_PIO->CTL[0].PUD &= ~(0x1 << CAN_Int.cantx); // Enable pull-up for GPIO (CANTXA)
126  TMC_BASE_PIO->CTL[0].MUX2 |= ((Uint32)0x1 << 30); // Configure GPIO for CANTXA
127  break;
128  default: EDIS;
129  return -2;
130  }
131  CAN_A_in_use=1;
132  }
133  else{
134  return -10;
135  }
136  break;
137  case 21: if(!CAN_B_in_use){
138  TMC_BASE_PIO->CTL[0].PUD &= ~(0x1 << CAN_Int.canrx); // Enable pull-up for GPIO(CANRXB)
139  TMC_BASE_PIO->CTL[0].QSEL2 |= (0x3 << 10); // Asynch qual for GPIO (CANRXB)
140  TMC_BASE_PIO->CTL[0].MUX2 |= (0x3 << 10); // Configure GPIO for CANRXB
141  switch(CAN_Int.cantx){
142  case 8: TMC_BASE_PIO->CTL[0].PUD &= ~(0x1 << CAN_Int.cantx); // Enable pull-up for GPIO8 (CANTXB)
143  TMC_BASE_PIO->CTL[0].MUX1 |= ((Uint32)0x2 << 16); // Configure GPIO8 for CANTXB
144  break;
145  case 12: TMC_BASE_PIO->CTL[0].PUD &= ~(0x1 << CAN_Int.cantx); // Enable pull-up for GPIO (CANTXB)
146  TMC_BASE_PIO->CTL[0].MUX1 |= ((Uint32)0x2 << 24); // Configure GPIO for CANTXB
147  break;
148  case 16: TMC_BASE_PIO->CTL[0].PUD &= ~(0x1 << CAN_Int.cantx); // Enable pull-up for GPIO (CANTXB)
149  TMC_BASE_PIO->CTL[0].MUX2 |= (0x2); // Configure GPIO for CANTXB
150  break;
151  case 20: TMC_BASE_PIO->CTL[0].PUD &= ~(0x1 << CAN_Int.cantx); // Enable pull-up for GPIO (CANTXB)
152  TMC_BASE_PIO->CTL[0].MUX2 |= (0x3 << 8); // Configure GPIO for CANTXB
153  break;
154  default: EDIS;
155  return -2;
156  }
157  CAN_B_in_use=1;
158  }
159  else{
160  return -10;
161  }
162  break;
163  case 30: if(!CAN_A_in_use){
164  TMC_BASE_PIO->CTL[0].PUD &= ~((Uint32)0x1 << CAN_Int.canrx); // Enable pull-up for GPIO(CANRXA)
165  TMC_BASE_PIO->CTL[0].QSEL2 |= ((Uint32)0x3 << 28); // Asynch qual for GPIO (CANRXA)
166  TMC_BASE_PIO->CTL[0].MUX2 |= ((Uint32)0x1 << 28); // Configure GPIO for CANRXA
167  switch(CAN_Int.cantx){
168  case 19: TMC_BASE_PIO->CTL[0].PUD &= ~((Uint32)0x1 << CAN_Int.cantx); // Enable pull-up for GPIO (CANTXA)
169  TMC_BASE_PIO->CTL[0].MUX2 |= (0x3 << 6); // Configure GPIO for CANTXA
170  break;
171  case 31: TMC_BASE_PIO->CTL[0].PUD &= ~((Uint32)0x1 << CAN_Int.cantx); // Enable pull-up for GPIO (CANTXA)
172  TMC_BASE_PIO->CTL[0].MUX2 |= ((Uint32)0x1 << 30); // Configure GPIO for CANTXA
173  break;
174  default: EDIS;
175  return -2;
176  }
177  CAN_A_in_use=1;
178  }
179  else{
180  return -10;
181  }
182  break;
183  default: EDIS;
184  return -1;
185  }
186 
187  EALLOW;
188  CAN->RIOC = 0x08; // CANRX pin is used for the CAN receive functions.
189  CAN->TIOC = 0x08; // CANTX pin is used for the CAN transmit functions
190  CAN->MC |= (0x1 << 10); // The data is received or transmitted least significant byte first
191  CAN->MC |= (0x1 << 13); // Select eCAN mode: 32 Mailboxes
192  CAN->MC |= ((Uint32)0x1 << 16); // Free mode: The peripheral continues to run in SUSPEND
193  TMC_BASE_SCR->PCLKCR0 |= (0x1 << 14);
194  EDIS;
195 
196  for(i=0;i<32;i++) { // Clear all values of mailboxes
197  CAN->MO[i].CTRL = 0;
198  CAN->MO[i].ID = 0;
199  CAN->MO[i].MDH = 0;
200  CAN->MO[i].MDL = 0;
201  }
202 
203  return CAN_setBaudrate(CAN, baudrate);
204 }
_TMS_CAN_MO::CTRL
TM_REG32 CTRL
Message Control.
Definition: TMC_BASE_CAN.h:14
_TMS_CAN::TRS
TM_REG32 TRS
Transmit request set.
Definition: TMC_BASE_CAN.h:27
Uint64
unsigned long long Uint64
64 Bit Variable: 0 .. 18.446.744.073.709.551.615
Definition: global_defines.h:23
_TMS_CAN_MO::MDL
TM_REG32 MDL
Message Data Low.
Definition: TMC_BASE_CAN.h:15
_TMS_CAN::MO
TMS_CAN_MO MO[32]
Mailboxes.
Definition: TMC_BASE_CAN.h:55
_CanMailbox::messageLength
Uint8 messageLength
Set amount of bytes to send or receive: (0-8)
Definition: can.h:22
_CanMailbox::Message_ID
Uint32 Message_ID
Message Identifier for CAN-Mailbox (standard: 11 Bit, extended: 29 Bit)
Definition: can.h:20
_CanMailbox::direction
CAN_direction direction
Set mailbox-direction: CAN_Tx / CAN_Rx.
Definition: can.h:23
CAN_getInterface
TMPS_CAN CAN_getInterface(Uint16)
get_can_interface for matching right CANInterfaces.
Definition: can.c:523
_TMS_CAN_MO::MDH
TM_REG32 MDH
Message Data High.
Definition: TMC_BASE_CAN.h:16
_TMS_CAN
CAN Register (TMC_BASE_CANA / TMC_BASE_CANB).
Definition: TMC_BASE_CAN.h:24
_TMS_CAN::MC
TM_REG32 MC
Master control.
Definition: TMC_BASE_CAN.h:35
CAN_Rx
@ CAN_Rx
Definition: can.h:15
_TMS_CAN::TIOC
TM_REG32 TIOC
TX I/O control.
Definition: TMC_BASE_CAN.h:46
_CanMailbox::extended
Uint8 extended
Set standard/extended Identifier-Mode: (standard = 0, extended = 1)
Definition: can.h:21
_TMS_CAN_MO::ID
TM_REG32 ID
Message Identifier.
Definition: TMC_BASE_CAN.h:13
CAN_direction
enum _CAN_direction CAN_direction
The enumeration for CAN directions.
_TMS_CAN::TA
TM_REG32 TA
Transmission acknowledge.
Definition: TMC_BASE_CAN.h:29
_CanInterface::canrx
Uint16 canrx
CAN Rx GPIO.
Definition: can.h:30
_CanInterface::cantx
Uint16 cantx
CAN Tx GPIO.
Definition: can.h:31
_TMS_CAN::ME
TM_REG32 ME
Mailbox enable.
Definition: TMC_BASE_CAN.h:25
_TMS_CAN::MD
TM_REG32 MD
Mailbox direction.
Definition: TMC_BASE_CAN.h:26
_TMS_CAN::RMP
TM_REG32 RMP
Receive message pending.
Definition: TMC_BASE_CAN.h:31
_TMS_CAN::RIOC
TM_REG32 RIOC
RX I/O control.
Definition: TMC_BASE_CAN.h:47
_CanMailbox::active
Uint8 active
Activate / Deactivate mailbox: 0 = inactive, 1= active.
Definition: can.h:24
CAN_Tx
@ CAN_Tx
Definition: can.h:15
Uint32
unsigned long Uint32
32 Bit Variable: 0 .. 4.294.967.295
Definition: global_defines.h:22