Package com.reduxrobotics.canand

Class CanandAddress

java.lang.Object
com.reduxrobotics.canand.CanandAddress
public class CanandAddress extends Object
Class representing the exact combination of CAN bus, product IDs, and device IDs that uniquely correspond to a Redux CAN device on a robot.

The full 29-bit CAN ID that actually gets put on the bus can be broken down into four components:

  1. A 5 bit device type (devType) that is product specific (the Canandmag is 7 for "gear tooth sensor")
  2. an 8-bit manufacturer code unique to each vendor (the Redux code is 14)
  3. 10 bits of API identifier
  4. a 6-bit device number (devId) that is user-configurable so one can have multiple of a device on a bus (this is what the "CAN Id" in robot code and vendor tuners usually refer to)
The WPILib docs elaborate on this in a bit more detail. Of note is that it breaks down the 10-bit API identifier into a 6-bit API class and 4-bit API index. Redux products, however, break it down into a 2 bit API page (page) and an 8 bit API index (apiIndex), which actually gets used for a device's message API.

The breakdown can be seen in the diagram provided below: 

 +-------------------+-------------------------------+-------+-------------------------------+-----------------------+
 |    Device Type    | Manufacturer ID   (redux=0xE) | Page  |           API Index           |   Device ID (devID)   |
 +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
 | 28| 27| 26| 25| 24| 23| 22| 21| 20| 19| 18| 17| 16| 15| 14| 13| 12| 11| 10|  9|  8|  7|  6|  5|  4|  3|  2|  1|  0|
 +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
Documentation on what each apiIndex value does as well as DBCs for Redux devices is available at https://docs.reduxrobotics.com/

In summary, to check if an incoming CAN message is from the device the CanandAddress represents, it needs to check:

  • the devType
  • the devId
  • and the CAN bus the message was sent from, as different devices on different buses can share identical IDs
to ensure they all match, leaving the apiIndex to be parsed by device class code. (The manufacturer ID is filtered for in the native driver portion of ReduxLib.)

Subclasses of CanandDevice will use this class for CAN i/o to a device, as this class provides a method to send CAN packets to the device it describes, and CanandEventLoop uses it to determine which messages to give to CanandDevice.handleMessage(com.reduxrobotics.canand.CanandMessage) by checking them against msgMatches(com.reduxrobotics.canand.CanandMessage), yielding an asynchronous method of receiving packets.

  • Constructor Details

    • CanandAddress

      public CanandAddress(MessageBus bus, int devType, int devId)
      Constructor with explicit CAN bus.
      Parameters:
      bus - the bus the address is associated with
      devType - the device type
      devId - the device CAN id

    • CanandAddress

      public CanandAddress(String busString, int devType, int devId)
      Construct new address with a bus string.
      Parameters:
      busString - bus string
      devType - device type
      devId - device id

    • CanandAddress

      public CanandAddress(int devType, int devId)
      Constructor with implicit Rio CAN bus.
      Parameters:
      devType - the device type
      devId - the device CAN id

  • Method Details

    • msgMatches

      public boolean msgMatches(CanandMessage msg)
      Checks if a CAN message matches against the device type, product id, and device can id
      Parameters:
      msg - a CanandMessage matching
      Returns:
      if there is a match

    • sendCANMessage

      public boolean sendCANMessage(int apiIndex, byte[] data)
      Sends a CAN message to the CanandAddress.
      Parameters:
      apiIndex - the API index the message should have (between 0-255 inclusive)
      data - 0-8 bytes of payload -- length of array will correspond to length of packet
      Returns:
      if the operation was successful

    • sendCANMessage

      public boolean sendCANMessage(int apiIndex, long data, int length)
      Sends a CAN message to the CanandAddress.
      Parameters:
      apiIndex - the API index the message should have (between 0-255 inclusive)
      data - 0-8 bytes of payload -- encoded as little endian long (lower bits == lower bytes)
      length - length of payload [0..8] inclusive
      Returns:
      if the operation was successful

    • sendRepeatingCANMessage

      public void sendRepeatingCANMessage(Repeater repeater, int apiIndex, long data, int length, int periodMs, int times)
      Sends a repeating CAN message to the CanandAddress.
      Parameters:
      repeater - The message repeater handle to use
      apiIndex - the API index of the message
      data - the data as a 64-bit long
      length - the length of the data
      periodMs - the period in milliseconds to repeat the message at
      times - the number of times to repeat the message before the repeater will sleep

    • sendRepeatingCANMessage

      public void sendRepeatingCANMessage(Repeater repeater, int apiIndex, long data, int length)
      Sends a repeating CAN message to the CanandAddress. This will repeat the message at a 40 millisecond frequency 25 times (1 second).
      Parameters:
      repeater - The message repeater handle to use
      apiIndex - the API index of the message
      data - the data as a 64-bit long
      length - the length of the data

    • getDeviceType

      public int getDeviceType()
      Returns the 5-bit device type.
      Returns:
      the device type

    • getDeviceId

      public int getDeviceId()
      Returns the user-settable device ID.
      Returns:
      the device ID

    • getBus

      public MessageBus getBus()
      Returns the bus associated with the address.
      Returns:
      bus