www.beck-ipc.com

@CHIP-RTOS - CAN Bus Driver API


    IPC@CHIP® Documentation Index

CAN Bus Driver

The assembly language API definition for sending and receiving data on the CAN (Controller Area Network) buses is defined here.   This API is only available in the SC1x3/SC2x @CHIP-RTOS.

The SC1x3/SC2x offers two CAN bus channels which can be operated with this API.

Each CAN channel has three hardware transmit registers and a four CAN message deep hardware receiver FIFO.   The CAN driver provides send and receive software FIFO's with user specified sizes around each of these hardware devices.

One required step in using the CAN ports is to call the CAN_Open_Port() function, which configures the port for a specific baud rate and sets the driver's software FIFO sizes.

In hardware, each receive channel offers three configurable receiver filters which can be used to reduce the load placed on the CPU by the CAN receivers.   These registers are configured with the CAN_Rx_Filters() function.

Use of the CAN API C library is recommended, rather than dealing directly with these low level assembly lanaguage interfaces specified here.

Topics

Interrupt 0xBF CAN Services

Service is selected by index in AH register.
  • 0x80:_Install dynamic link, then call function
  • 0x81:_CAN_API_OPEN, Open a specified CAN port
  • 0x82:_CAN_API_RX_FILT, Initialize receiver filter
  • 0x83:_CAN_API_SEND, Send a message
  • 0x84:_CAN_API_RCV, Receive a message
  • 0x85:_CAN_API_PEEK, Look at message
  • 0x86:_CAN_API_RECONFIG, Reconfigure CAN port
  • 0x87:_CAN_API_STATUS, Check port status
  • 0x88:_CAN_API_CONTROL, Port controls
  • 0x89:_CAN_API_CLOSE, Close a CAN port
  • 0x8A:_CAN_API_EVENT, Wait on CAN event
  • 0x8B:_CAN_API_CALLBACK, Install a ISR callback
  • 0x8C:_CAN_API_ERRORS, Check port error counts


  • Interrupt 0xBF service 0x80:     Install dynamic link, then call function

    This function installs a far JMP opcode in the vicinity of the return instruction pointer to enter the specified CAN API function directly from the user code.   This function is provided for efficiency in real-time applications.

    Parameters

    AH
    0x80

    AL
    Dynamic link index for function whose link is desired from following list:

    Index     CAN Function

    0         CAN_Open_Port    Open a CAN bus port
    1         CAN_Rx_Filters   Control CAN receiver filters
    2         CAN_Send          Send CAN message
    3         CAN_Recv          Pick up received CAN message
    4         CAN_Peek          Pick up CAN message and leave it in queue
    5         CAN_Reconfigure  Reconfigure an open CAN bus port
    6         CAN_Status        Get CAN port status
    7         CAN_Control       Control FIFO's and device enables
    8         CAN_Close_Port    Close a CAN bus port
    9         CAN_Event_Sleep   Await event on either CAN port
    10        CAN_Set_Callback  Install/Remove CAN ISR callback vector
    11        CAN_Error_Counts  Read out Tx/Rx error counts

    Return Value

    Instruction Pointer is moved back 10 bytes so that newly installed far JMP will execute immediately.

    (Refer to respective linked function's documention for further return value information.)

    Note: All dynamically linked functions are free to use all registers except for DS, SI, DI, and BP registers which are preserved.  This matches the Paradigm C, Borland C 5.02 and Microsoft Visual C 1.52 calling conventions.

    Comments

    This API service is intended to be used by the RTOS C-Library exclusively.   It is not recommended that it be used directly from within user applications.

    A JMP FAR instruction will be written 10 bytes before the user's return instruction pointer.  This far jump will transfer control directly into the RTOS from the user code when executed.   This new far JMP will execute immediately upon return from this software interrupt due to the instruction pointer adjustment performed within the call.

    Interrupts are masked and restored to their state on entry.

    Since the code at calling site will be patched by this RTOS call, it is important that it has exactly the following form (the link index carried in AL register will vary)

                
    JMP SHORT over_patch  ; Occupies 2 bytes of instruction code here
    NOP    ; Never executed (1 byte)
    NOP    ; Never executed (1 byte)
    NOP    ; never executed (1 byte)
    over_patch:  ; Linker overwrites above 5 bytes with JMP FAR instruction
    MOV AX,08000h  ; AH = 0x80, AL = 0 = index for CAN_Open_Port()
    INT 0BFh

    Supported since or modified in @CHIP-RTOS version

      SC12SC13SC11SC1x3SC2x
      n/an/an/aV1.07V1.00

    Top of list
    Index page
    Interrupt 0xBF service 0x81:     CAN_API_OPEN, Open a specified CAN port

    Initializes a CAN port in preparation for use.

    Parameters

    AH
    0x81 (= CAN_API_OPEN)

    DX
    CAN port specifier:   0 for CAN0 port, or 1 for CAN1 port

    ES:BX
    Far pointer to a CAN_PORT_INIT data structure set by user prior to calling.   The CAN driver treats this data as read only.

    Return Value

    AX = 0 success
    AX non-zero = error code

    Comments

    Either this function or the CAN_Rx_Filters (required in order to receive any CAN messages) would be the starting point in preparing a CAN port for use.   This function allocates receive and send FIFOs.   The port is initialized for operation at the specified baud rate.

    An RTX event group is allocated if this action has not already been taken for the adjacent CAN port.   (The driver uses a single RTX event group for the CAN port pair.)

    No operation is performed if the port has already been opened.   In this case an error code CAN_EC_PORT_ALREADY_OPENED is returned.   If necessary, limited configuration changes on an open CAN port can be made with the CAN_Reconfig API.
    Inside this API the interrupts are masked for a short period and then re-enabled.   This function is reentrant.

    When CAN1 is opened, the PIO14 and PIO15 are configured for NORMAL operation.

    Important Note:

      No CAN messages will be received until the port's receiver filters have been enabled for reception using the CAN_Rx_Filters API.   Following a system reset, the CAN receiver filters are initialized to reject all incoming CAN messages by default.

    Beck C-Library Usage

    CAN_Open_Port() - Open one of the CAN ports

    Related Topics

    CAN_Rx_Filters - Initialize receiver filter
    CAN_Close_Port - Close specified port
    CAN_Reconfig - Adjust configuration

    Supported since or modified in @CHIP-RTOS version

      SC12SC13SC11SC1x3SC2x
      n/an/an/aV1.07V1.00

    Top of list
    Index page
    Interrupt 0xBF service 0x82:     CAN_API_RX_FILT, Initialize receiver filter

    Initializes a set of receiver acceptance filter registers.

    Parameters

    AH
    0x82 (= CAN_API_RX_FILT)

    DX
    CAN port specifier:   0 for CAN0 port, or 1 for CAN1 port

    CX
    Filter index: 0, 1 or 2

    ES:BX
    Far pointer to a CAN_RX_FILT data structure set by user prior to calling.   The CAN driver treats this data as read only.   Set to NULL to disable respective receiver filter.

    Return Value

    AX = 0 success
    AX non-zero = error code

    Comments

    This function must be called in order to receive any CAN messages on respective port.   If all three message filters are disabled, no messages are received.   This is the default condition following a reset.

    This function is used to initialize one of the CAN receiver's three sets of acceptance filter registers.   The receiver acceptance filters may be used to limit the incoming message traffic to those CAN messages which apply to this node in the network.

    To receive all messages, one message filter must be enabled and programmed with all its fields as "don't care" ('1's).

    This function may be used either before or after the respective CAN port has been opened.

    Inside this API the interrupts are masked for a short period and then re-enabled.   This function is reentrant.

    Beck C-Library Usage

    CAN_Rx_Filters() - Initialize a receiver filter

    Related Topics

    CAN_Open_Port - Initialize CAN port

    Supported since or modified in @CHIP-RTOS version

      SC12SC13SC11SC1x3SC2x
      n/an/an/aV0.90V1.00

    Top of list
    Index page
    Interrupt 0xBF service 0x83:     CAN_API_SEND, Send a message

    Queue a CAN message for output on specified transmitter.

    Parameters

    AH
    0x83 (= CAN_API_SEND)

    DX
    CAN port specifier:   0 for CAN0 port, or 1 for CAN1 port

    CX
    Transmit channel:
      0 for Tx #1
      1 for Tx #2
      2 for Tx #3

    or when operating in CAN_TX_PRIORITY_QUEUES mode:
      0 for output through the normal priority send queue
      1 for output through the high priority send queue
      (2 works same as 1 here)

    ES:BX
    Far pointer to a CAN_MSG data structure set by user prior to calling.   The CAN driver treats this data as read only.

    Return Value

    AX = 0 success
    AX non-zero = error code

    Comments

    This API is used to send CAN messages.   Refer to the C-Library CAN_Send() API documentation for a detailed explanation of this API's various modes of operation.

    Inside this API the interrupts are masked for a short period and then re-enabled.   This function is reentrant.

    Beck C-Library Usage

    CAN_Send() - Transmit a CAN message

    Related Topics

    CAN_Recv - Get a received CAN message
    CAN_Control - Enable/disable transmitter

    Supported since or modified in @CHIP-RTOS version

      SC12SC13SC11SC1x3SC2x
      n/an/an/aV1.07V1.00

    Top of list
    Index page
    Interrupt 0xBF service 0x84:     CAN_API_RCV, Receive a message

    Pick up a received CAN message from receiver queue, removing the message from the queue.

    Parameters

    AH
    0x84 (= CAN_API_RCV)

    DX
    CAN port specifier:   0 for CAN0 port, or 1 for CAN1 port

    CX
    Time-out
      Negative value:   No wait, return immediately
      Zero:   Wait forever for a CAN message
      Positive value:   Maximum milliseconds to wait for a CAN message

    ES:BX
    (Output Parameter)   Far pointer to a CAN_MSG data structure where the driver will return the received CAN message.

    Return Value

    AX = 0 success
    AX non-zero = error code

    Comments

    This function is used to pick up the next received CAN message from the receiver FIFO queue.   The time-out parameter in CX register allows the caller to optionally sleep on the receiver a specified number of milliseconds until a received CAN message is available.

    Note that if the CAN port is closed, the CAN_Close_Port API strobes the event bits to assure that a program thread which is sleeping on the receiver within this API will return.


    Inside this API the interrupts are masked for a short period and then re-enabled.   This function is reentrant.

    Important Note:

      No CAN messages will be received until the port's receiver filters have been enabled for reception using the CAN_Rx_Filters API.   Following a system reset, the CAN receiver filters are initialized to reject all incoming CAN messages by default.

    Beck C-Library Usage

    CAN_Recv() - Receive a CAN message

    Related Topics

    CAN_Peek - Read out a message, leave it in queue
    CAN_Rx_Filters - Initialize CAN receiver filters
    CAN_Send - Send a CAN message
    CAN_Close_Port - Close a CAN port

    Supported since or modified in @CHIP-RTOS version

      SC12SC13SC11SC1x3SC2x
      n/an/an/aV0.90V1.00

    Top of list
    Index page
    Interrupt 0xBF service 0x85:     CAN_API_PEEK, Look at message

    Pick up a received CAN message from receiver queue, but leave the message in the queue.

    Parameters

    AH
    0x85 (= CAN_API_PEEK)

    DX
    CAN port specifier:   0 for CAN0 port, or 1 for CAN1 port

    ES:BX
    (Output Parameter)   Far pointer to a CAN_MSG data structure where the driver will return the received CAN message.

    Return Value

    AX = 0 success
    AX non-zero = error code

    Comments

    This function picks up a copy of the next received CAN message from the receiver queue FIFO without removing that message from the queue.

    Inside this API the interrupts are masked for a short period and then re-enabled.   This function is reentrant.

    Important Note:

      No CAN messages will be received until the port's receiver filters have been enabled for reception using the CAN_Rx_Filters API.   Following a system reset, the CAN receiver filters are initialized to reject all incoming CAN messages by default.

    Beck C-Library Usage

    CAN_Peek() - Look at next CAN message

    Related Topics

    CAN_Recv - Get a received message
    CAN_Rx_Filters - Initialize CAN receiver filters

    Supported since or modified in @CHIP-RTOS version

      SC12SC13SC11SC1x3SC2x
      n/an/an/aV0.90V1.00

    Top of list
    Index page
    Interrupt 0xBF service 0x86:     CAN_API_RECONFIG, Reconfigure CAN port

    Adjust baud rate or bit timing parameters on an open CAN port.

    Parameters

    AH
    0x86 (= CAN_API_RECONFIG)

    DX
    CAN port specifier:   0 for CAN0 port, or 1 for CAN1 port

    ES:BX
    Far pointer to a CAN_CONFIG data structure.   The driver treats this data structure in a read only manner.

    Return Value

    AX = 0 success
    AX non-zero = error code

    Comments

    This function allows bit timing to be adjusted on a CAN port which has already been opened.   (Under normal circumstances it is not expected that this function will be used.)

    This function may also be used to manually switch back on a CAN bus following a bus off event.   By default, this is performed automatically by the driver.   However the user may specify a manual restart mode.

    A successful call to this API zeroes the port's CANn_EV_BUS_OFF event.

    Inside this API the interrupts are masked for a short period and then re-enabled.   This function is reentrant.

    Beck C-Library Usage

    CAN_Reconfig() - Adjust baud rate or bit timing parameters

    Related Topics

    CAN_Open_Port - Open a CAN port
    CAN_Rx_Filters - Configure receiver filters
    CAN_Close_Port - Close a CAN port
    CAN_Event - Wait on CAN event

    Supported since or modified in @CHIP-RTOS version

      SC12SC13SC11SC1x3SC2x
      n/an/an/aV1.11V1.00

    Top of list
    Index page
    Interrupt 0xBF service 0x87:     CAN_API_STATUS, Check port status

    Read out status information for specified CAN port.

    Parameters

    AH
    0x87 (= CAN_API_STATUS)

    DX
    CAN port specifier:   0 for CAN0 port, or 1 for CAN1 port

    ES:BX
    (Output Parameter)   Far pointer to a CAN_STATUS data structure.   The driver writes the status information into this data structure.

    Return Value

    AX = 0 success
    AX non-zero = error code

    Comments

    This function reports various status information concerning the specified CAN port.   After reading out the reported error flags, the internal error flag registers are cleared (destructive read).


    Inside this API the interrupts are masked for a short period and then re-enabled.   This function is reentrant.

    Beck C-Library Usage

    CAN_Status() - Read out status information

    Related Topics

    CAN_Error_Counts - CAN port error counts
    CAN_Control - CAN port control

    Supported since or modified in @CHIP-RTOS version

      SC12SC13SC11SC1x3SC2x
      n/an/an/aV0.90V1.00

    Top of list
    Index page
    Interrupt 0xBF service 0x88:     CAN_API_CONTROL, Port controls

    Enable or disable specified channels. Purge specified FIFO's.

    Parameters

    AH
    0x88 (= CAN_API_CONTROL)

    DX
    CAN port specifier:   0 for CAN0 port, or 1 for CAN1 port

    BX
    "Purge FIFO's" bit field

    CX
    "Enable Device" bit field

    SI
    "Disable Device" bit field

    Return Value

    AX = 0 success
    AX non-zero = error code

    Comments

    This function provides a way to enable or disable the receiver and the three individual transmit register channels.  Also, any or all of the receiver or transmit FIFO's can be cleared.

    The CAN_Open_Port API enables all three transmitters and optionally the receiver as well.   So this provisional API here is not necessarily required for CAN port operation.

    The input parameters in the BX, CX, and SI registers are each bit fields with the identical bit mapping as follows:

      CAN_RX_SEL   = 0x8000, Receiver control flag
      CAN_TX1_SEL = 0x0800, TX1 register control flag
      CAN_TX2_SEL = 0x1000, TX2 register control flag
      CAN_TX3_SEL = 0x2000, TX3 register control flag

    A bit set indicates that the action associated with the particular CPU register should be taken for the device designed by the bit.   For example if:

      BX = CAN_RX_SEL | CAN_TX2_SEL ;
           ... and ...
      CX = CAN_TX3_SEL ;
           ... and ...
      SI = CAN_TX2_SEL ;

    then this API function will purge (delete its contents) the receiver FIFO and the FIFO associated with transmit register #2.   It will enable transmit register #3.   It will disable transmit register #2.

    When transmit FIFO's are purged, any CAN message pending output in the specified hardware transmit register is also aborted.

    In the non-sense case where a device's bit is set in both CX and SI registers, indicating that both an enabling and disabling action should be taken on the same device, the enabling will take precedence and the device will be enabled.

    Inside this API the interrupts are masked for a short period and then re-enabled.   This function is reentrant.

    Beck C-Library Usage

    CAN_Control() - Enable or disable specified channels

    Related Topics

    CAN_Open_Port - Configure CAN port
    CAN_Status - Read CAN port status

    Supported since or modified in @CHIP-RTOS version

      SC12SC13SC11SC1x3SC2x
      n/an/an/aV0.90V1.00

    Top of list
    Index page
    Interrupt 0xBF service 0x89:     CAN_API_CLOSE, Close a CAN port

    Close down a specified CAN port.

    Parameters

    AH
    0x89 (= CAN_API_CLOSE)

    DX
    CAN port specifier:   0 for CAN0 port, or 1 for CAN1 port

    Return Value

    AX = 0 success
    AX non-zero = error code

    Comments

    This function closes a CAN port, releasing any resources it was using (e.g. heap memory for FIFO's and RTX event group).   Prior to releasing the event group, the event bits in the RTX event group associated with this port are strobed in order to release any program threads which were waiting on events for this port which is now being closed.

    Any user callback vectors that had been set for this port will be removed.

    The CAN device is deactivated.   Any pending transmission is aborted.   Aborting a pending transmission requires some additional time beyond when this API returns such that if the port were to be immediately reopened, a subsequent call to CAN_Send could fail due to a transmit buffer still busy condition.

    Inside this API the interrupts are masked for a short period and then re-enabled.   This function is reentrant.

    Beck C-Library Usage

    CAN_Close_Port() - Close a CAN port

    Related Topics

    CAN_Port_Open - Open a CAN port
    CAN_Recv - Get a received message
    CAN_Event_Sleep - Sleep on CAN event

    Supported since or modified in @CHIP-RTOS version

      SC12SC13SC11SC1x3SC2x
      n/an/an/aV0.90V1.00

    Top of list
    Index page
    Interrupt 0xBF service 0x8A:     CAN_API_EVENT, Wait on CAN event

    Sleep for specified amount of time, awaiting any CAN event among those specified.

    Parameters

    AH
    0x8A (= CAN_API_EVENT)

    DX
    Set of CAN events to wait for (bit field)

    CX
    Time-out
      Negative value:   No wait, return immediately
      Zero:   Wait forever for the CAN event(s)
      Positive value:   Maximum milliseconds to wait for the CAN event(s)

    Return Value

    AX = 0 indicates no events occurred (time-out)
    AX non-zero = event bits which came true among those that were specified in DX.

    Comments

    This function sleeps on the event group used internally by the CAN driver, awaiting specified CAN events.   Note that the events can be on either of the two CAN ports.

    The events specified in DX register can be any combination of the following events:

      CAN0_EV_RX_RDY = 0x0001, CAN0 Receiver data ready
      CAN0_EV_TX1_EMP = 0x0002, CAN0 Transmitter #1 queue empty
      CAN0_EV_TX2_EMP = 0x0004, CAN0 Transmitter #2 queue empty
      CAN0_EV_TX3_EMP = 0x0008, CAN0 Transmitter #3 queue empty
      CAN0_EV_BUS_OFF = 0x0010, CAN0 Bus off condition

      CAN1_EV_RX_RDY = 0x0100, CAN1 Receiver data ready
      CAN1_EV_TX1_EMP = 0x0200, CAN1 Transmitter #1 queue empty
      CAN1_EV_TX2_EMP = 0x0400, CAN1 Transmitter #2 queue empty
      CAN1_EV_TX3_EMP = 0x0800, CAN1 Transmitter #3 queue empty
      CAN1_EV_BUS_OFF = 0x1000, CAN1 Bus off condition

    This function returns when any one of the specified events occurs.   If no events are specified the function returns immediately with zero in AX.   Any event bits in DX which apply to a port which is not open will be ignored and treated as zeros.

    This function has no affect on the event flags.   Event flags are not cleared as a side affect of this function call.

    The CANn_EV_RX_RDY event is cleared after the respective receiver queue is emptied by calls to the CAN_Recv API.   The CANn_EV_BUS_OFF event is cleared by calls to CAN_Open_Port, CAN_Reconfig or CAN_Close_Port API.

    The transmit event flags operate differently depending on whether or not the CAN_TXQ1_DRIVES_ALL or CAN_TX_PRIORITY_QUEUES modes are being used.   When either of these transmit modes are used, the CAN_Send API clears the transmit flags for all channels associated with the software queue that the output CAN message is directed to.   And this same group of transmit channel event flags will be set to '1' simultaneously when the software queue(s) feeding those channels is (are) emptied.   However there may still be a CAN message or two awaiting output in the CAN hardware transmit registers after the events are set.

    When the transmitters are operated in neither CAN_TXQ1_DRIVES_ALL nor CAN_TX_PRIORITY_QUEUES mode, the CAN_Send API clears the single event flag bit associated with the channel that the CAN message is directed.   Then the respective transmit event bit will be set to '1' after the hardware register is emptied (CAN message sent) and no further queued messages were pending for this transmit device.

    A port closing will cause this function to return if any event wait bits applied to that port which closed.   In this case the event flags returned for the closed port should be ignored, since they were created artificially.

    The handle to the event group which the CAN driver uses to implement this API can be retrieved with the RTX_Find_EventGroup() API provided that the user has not stepped on the name given this group with yet another event group by the same name.   The name given this event group by the CAN driver is "_CAN".   This event group exists only so long as one of the two CAN ports is opened.

    An event group provides 16 independent events, of which this CAN driver uses ten (five events for each of two CAN ports).   These ten event bits are specified above.   The other six event flags are available to the user.   If the user chooses to use these additional event flags for their own purposes then they should call directly the RTX_Wait_For_Event() rather then using this API.   When this CAN_API_EVENT API is used, any event flags outside the scope of the ten used by the CAN driver are ignored.   Furthermore, this API only waits for event flag '1' conditions.   Using the RTX_Wait_For_Event() API directly, the user would have more flexibility.

    Inside this API the interrupts are masked for a short period and then re-enabled.   This function is reentrant.

    Beck C-Library Usage

    CAN_Event_Sleep() - Sleep on event

    Related Topics

    CAN_Open_Port - Open a CAN port
    CAN_Close_Port - Close a CAN port
    CAN_Recv - Receive CAN message
    CAN_Send - Send CAN message
    CAN_Set_Callback - Set ISR callback
    CAN_Reconfig - Reconfigure port

    Supported since or modified in @CHIP-RTOS version

      SC12SC13SC11SC1x3SC2x
      n/an/an/aV0.90V1.00

    Top of list
    Index page
    Interrupt 0xBF service 0x8B:     CAN_API_CALLBACK, Install a ISR callback

    Close down a specified CAN port.

    Parameters

    AH
    0x8B (= CAN_API_CALLBACK)

    DX
    CAN port specifier:   0 for CAN0 port, or 1 for CAN1 port

    ES:BX
    Vector to user's callback procedure

    CX
    Events bit field

    Return Value

    AX = 0 success
    AX non-zero = error code

    Comments

    This function either installs or removes a user callback procedure that is called from within the CAN driver's Interrupt Service Routine (ISR) upon specified events.

    The vector in ES:BX registers can be set to NULL to remove existing vectors.

    Refer to the C-Library CAN_Set_Callback() API documentation for further details.

    Beck C-Library Usage

    CAN_Set_Callback() - Set callback

    Related Topics

    CAN_Close_Port - Close a CAN port
    CAN_Port_Open - Open a CAN port
    CAN_Recv - Get a received message
    CAN_Event_Sleep - Sleep on CAN event

    Supported since or modified in @CHIP-RTOS version

      SC12SC13SC11SC1x3SC2x
      n/an/an/aV1.06V1.00

    Top of list
    Index page
    Interrupt 0xBF service 0x8C:     CAN_API_ERRORS, Check port error counts

    Read out the transmitter and receiver error counts and bus error status for a specified CAN port.

    Parameters

    AH
    0x8C (= CAN_API_ERRORS)

    DX
    CAN port specifier:   0 for CAN0 port, or 1 for CAN1 port

    ES:BX
    (Output Parameter)   Far pointer to a CAN_ERRORS data structure.   The driver writes the error status information into this data structure.

    Return Value

    AX = 0 success
    AX non-zero = error code

    Comments

    This function reports transmitter/receiver error counts as specified by the Bosch CAN specification.   Also some discrete bits are reported which indicate the bus error state.

    Inside this API the interrupts are masked for a short period and then re-enabled.   This function is reentrant.

    Beck C-Library Usage

    CAN_Error_Counts() - Read out error counts

    Related Topics

    CAN_Status - CAN port status
    CAN_Control - CAN port control

    Supported since or modified in @CHIP-RTOS version

      SC12SC13SC11SC1x3SC2x
      n/an/an/aV1.07V1.00

    Top of list
    Index page


    End of document