EMAC CAN Interface - Revision history

Kyoungmeyer at 20:25, 20 January 2016

2016-01-20T20:25:00Z

Mdean: Fixed two comma splices. Fixed a few grammatical issues. Noted missing keywords for SEO and an oddity in one code example. Marked buggy.

2016-01-20T19:54:03Z

Fixed two comma splices. Fixed a few grammatical issues. Noted missing keywords for SEO and an oddity in one code example. Marked buggy.

Kyoungmeyer at 17:35, 20 January 2016

2016-01-20T17:35:17Z

Kyoungmeyer at 17:34, 20 January 2016

2016-01-20T17:34:35Z

Kyoungmeyer at 20:32, 19 January 2016

2016-01-19T20:32:14Z

Kyoungmeyer at 19:33, 19 January 2016

2016-01-19T19:33:21Z

Kyoungmeyer at 18:01, 19 January 2016

2016-01-19T18:01:42Z

Kyoungmeyer at 23:34, 18 January 2016

2016-01-18T23:34:02Z

Kyoungmeyer at 21:31, 18 January 2016

2016-01-18T21:31:07Z

Kyoungmeyer at 20:03, 18 January 2016

2016-01-18T20:03:03Z

@@ Line 1: / Line 1: @@
-{{todo| Review (01.18.2016-10:45->KY+);(01.20.2016-13:50->MD-)|Klint Youngmeyer| project=OE 5.0,KY,MG,MD,Buggy }}
+{{todo| Review (01.18.2016-10:45->KY+);(01.20.2016-13:50->MD-)(01.20.2016-14:23->KY+)|Klint Youngmeyer| project=OE 5.0,KY,MG,MD,Review }}
 {{#seo:
 |title=EMAC CAN Interface
 |titlemode=append
-|keywords=
+|keywords=can,socketcan,canbus,cansend,candump,linux
 |description=This page describes how to use the CAN interface on EMAC boards.
 }}
 <!-- /*********************************************************************************************************/ -->
 <!-- /****************************************  Page Description Text  ****************************************/ -->
@@ Line 126: / Line 123: @@
 frame.can_id = id;
 for(j = 0; j < dlc; j++){
-     frame.data[j] = 0x1 * (rand()%99); // Assign 8 random hex bytes to the payload
+     frame.data[j] = rand() % 0x100; // Assign 8 random hex bytes to the payload
+}
 frame.can_dlc = dlc;
 </syntaxhighlight>
 ====CAN Write====
@@ Line 253: / Line 230: @@
      frame.can_id = id;
      for(j = 0; j < dlc; j++){
-         frame.data[j] = 0x1 * (rand()%99); // Assign 8 random hex bytes to the payload
+         frame.data[j] = rand() % 0x100; // Assign 8 random hex bytes to the payload
+     }
      frame.can_dlc = dlc;

@@ Line 1: / Line 1: @@
-{{todo| Review (01.18.2016-10:45->KY+)|Klint Youngmeyer| project=OE 5.0,KY,MG,Review }}
+{{todo| Review (01.18.2016-10:45->KY+);(01.20.2016-13:50->MD-)|Klint Youngmeyer| project=OE 5.0,KY,MG,MD,Buggy }}
 {{#seo:
 |title=EMAC CAN Interface
@@ Line 6: / Line 6: @@
 |description=This page describes how to use the CAN interface on EMAC boards.
 }}
 <!-- /*********************************************************************************************************/ -->
@@ Line 30: / Line 32: @@
 The CAN bus is able to be accessed from the command line, or using a C library on EMAC products (with CAN support).
 ===CAN Bus Setup===
-Before using the CAN interface on an EMAC device, two commands must be run. These commands could be scripted to be run at startup, see [[EMAC_OE_Boot_Process_Customization|this page]] for details.
+Before using the CAN interface on an EMAC device, two commands must be run. These commands could be scripted to be run at startup; see [[EMAC_OE_Boot_Process_Customization|this page]] for details.
 {{note|The settings in the first command may need to be changed according to the application in question.}}
@@ Line 96: / Line 98: @@
 Using CAN with C programming on an EMAC Linux board involves using the SocketCAN implementation.
 ====CAN Sockets====
-To open a CAN connection, first a socket must be opened. CAN sockets can be either <code>raw</code> or <code>broadcast manager</code>, for this document <code>raw</code> will be used. After creation of a <code>raw</code> CAN socket, it must be bound to an address with the <code>bind()</code> system call. This address is specified by a <code>sockaddr_can</code> struct cast to a <code>sockaddr</code> struct. The following code snippet demonstrates how to open a CAN socket on <code>can0</code> with no error checking.
+To open a CAN connection, first a socket must be opened. CAN sockets can be either <code>raw</code> or <code>broadcast manager</code>; for this document, <code>raw</code> will be used. After creation of a <code>raw</code> CAN socket, it must be bound to an address with the <code>bind()</code> system call. This address is specified by a <code>sockaddr_can</code> struct cast to a <code>sockaddr</code> struct. The following code snippet demonstrates how to open a CAN socket on <code>can0</code> with no error checking.
 <syntaxhighlight lang=c>
@@ Line 128: / Line 130: @@
 frame.can_dlc = dlc;
 </syntaxhighlight>
 ====CAN Write====
-Sending a CAN frame is accomplished by simply using the <code>write()</code> system call. <code>write()</code> takes 3 arguments: a file descriptor, a buffer(data) to write, and the size of data to write. In this case, the file descriptor is the CAN socket that was opened previously, the buffer will will be the address to the frame struct, and the size of data is the size of the CAN frame struct. The return value of <code>write()</code> is the number of bytes written, and is valuable for error checking. The following code snippet illustrates how to write the frame to the socket that were setup in the previous sections.
+Sending a CAN frame is accomplished by simply using the <code>write()</code> system call. <code>write()</code> takes 3 arguments: a file descriptor, a buffer(data) to write, and the size of data to write. In this case, the file descriptor is the CAN socket that was opened previously, the buffer will will be the address to the frame struct, and the size of data is the size of the CAN frame struct. The return value of <code>write()</code> is the number of bytes written and is valuable for error checking. The following code snippet illustrates how to write a frame to the socket that was set up in the previous sections.
 <syntaxhighlight lang=c>
 int wbytes;
@@ Line 137: / Line 160: @@
 ====CAN Read====
-Reading from a CAN frame is very similar to writing to one. Reading is accomplished with the <code>read()</code> system call. <code>read()</code> takes 3 arguments: a file descriptor, a buffer(data) to put the read data in, and the size of data to read. In this case, the file descriptor is the CAN socket that was opened previously, the buffer will will be the address to a new frame struct, and the size of data is the size of the CAN frame struct. The return value of <code>read()</code> is the number of bytes read, and is valuable for error checking. When write is called, it will block the program from continuing until data is read. The following code snippet illustrates how to read from the CAN bus to a frame and print that frame to <code>stdout</code> in a similar format to <code>candump</code> without error checking.
+Reading from a CAN frame is very similar to writing to one. Reading is accomplished with the <code>read()</code> system call. <code>read()</code> takes 3 arguments: a file descriptor, a buffer(data) to put the read data in, and the size of data to read. In this case, the file descriptor is the CAN socket that was opened previously, the buffer will will be the address to a new frame struct, and the size of data is the size of the CAN frame struct. The return value of <code>read()</code> is the number of bytes read and is valuable for error checking. When write is called, it will block the program from continuing until data is read. The following code snippet illustrates how to read from the CAN bus to a frame and print that frame to <code>stdout</code> in a similar format to <code>candump</code> without error checking.
 <syntaxhighlight lang=c>
 struct can_frame frame2;

@@ Line 1: / Line 1: @@
-{{todo| InProgress (01.18.2016-10:45->KY+)|Klint Youngmeyer| project=OE 5.0,KY,InProgress }}
+{{todo| Review (01.18.2016-10:45->KY+)|Klint Youngmeyer| project=OE 5.0,KY,MG,Review }}
 {{#seo:
 |title=EMAC CAN Interface

@@ Line 46: / Line 46: @@
 Of these five, the most easily used are <code>cansend</code> and <code>candump</code>.
 ====cansend====
-<code>cansend</code>, as the name implies, is used for sending CAN messages over the bus. Up to eight bytes at a time can be sent using <code>cansend</code>, these bytes are formatted at a space separated list of hexadecimal octets e.g. "<code>0xBE 0x42 0xEF 0x9A</code>." The command for sending the previous hexadecimal digits on the <code>can0</code> device is:
+<code>cansend</code>, as the name implies, is used for sending CAN messages over the bus. Up to eight bytes at a time can be sent using <code>cansend</code>, these bytes are formatted at a space separated list of hexadecimal octets e.g. "<code>0xBE 0x42 0xEF 0x9A</code>." The command for sending the previously mentioned hexadecimal digits on the <code>can0</code> device is:
 {{cli | cansend can0 0xBE 0x42 0xEF 0x9A | hostname=ipac9x25}}
@@ Line 54: / Line 54: @@
 {{clos}}
-<code>cansend</code> uses, by default, an identifier of <code>0x01</code>. If an identifier other than default, the <code>-i 0x<IDENT></code> option must be passed on the command line. In the following example, the identity <code>0x89</code> is used.
+<code>cansend</code> uses, by default, an identifier of <code>0x01</code>. If an identifier other than default is desired, the <code>-i 0x<IDENT></code> option must be passed on the command line. In the following example, the identity <code>0x89</code> is used.
 {{cli | cansend can0 -i 0x89 0xBE 0x42 0xEF 0x9A | hostname=ipac9x25}}
@@ Line 63: / Line 63: @@
 Using the standard identity, the length of the identity is limited to a maximum hexadecimal value of <code>0x7FF</code>. If a larger identity is needed, the <code>-e</code> option can be passed, which allows an extended CAN frame with a maximum hexadecimal value of <code>0x1FFFFFFF</code>. The following example shows a message with an extended frame.
 {{cli | cansend can0 -e -i 0x8008 0xBE 0x42 0xEF 0x9A | hostname=ipac9x25}}
@@ Line 70: / Line 69: @@
 <0x00008008> [4] be 42 ef 9a
 {{clos}}
 ====candump====
 <code>candump</code> is used to receive messages over CAN. These messages can be output to <code>stdout</code> or directly to a file. <code>candump</code> will run until it is killed, either with <code>Ctrl-C</code> or a <code>kill</code> command. The following command shows how to receive any message over CAN and output it to <code>stdout</code>. A command of <code>cansend can0 0xBE 0x42 0xEF 0x9A</code> was given on a connected board.
@@ Line 96: / Line 96: @@
 Using CAN with C programming on an EMAC Linux board involves using the SocketCAN implementation.
 ====CAN Sockets====
-To open a CAN connection, first a socket must be opened. CAN sockets can be either ''raw'' or ''broadcast manager'', for this document ''raw'' will be used. After creation of a ''raw'' CAN socket, it must be bound to an address with the <code>bind()</code> system call. This address is specified by a <code>sockaddr_can</code> struct cast to a <code>sockaddr</code> struct. The following code snippet demonstrates how to open a CAN socket on <code>can0</code> with no error checking.
+To open a CAN connection, first a socket must be opened. CAN sockets can be either <code>raw</code> or <code>broadcast manager</code>, for this document <code>raw</code> will be used. After creation of a <code>raw</code> CAN socket, it must be bound to an address with the <code>bind()</code> system call. This address is specified by a <code>sockaddr_can</code> struct cast to a <code>sockaddr</code> struct. The following code snippet demonstrates how to open a CAN socket on <code>can0</code> with no error checking.
 <syntaxhighlight lang=c>

@@ Line 131: / Line 131: @@
 Sending a CAN frame is accomplished by simply using the <code>write()</code> system call. <code>write()</code> takes 3 arguments: a file descriptor, a buffer(data) to write, and the size of data to write. In this case, the file descriptor is the CAN socket that was opened previously, the buffer will will be the address to the frame struct, and the size of data is the size of the CAN frame struct. The return value of <code>write()</code> is the number of bytes written, and is valuable for error checking. The following code snippet illustrates how to write the frame to the socket that were setup in the previous sections.
 <syntaxhighlight lang=c>
-int nbytes;
+int wbytes;
-nbytes = write(s, &frame, sizeof(struct can_frame));
+wbytes = write(s, &frame, sizeof(struct can_frame));
 </syntaxhighlight>
 ====CAN Read====
 ====CAN Example Program====
 This information can be found in much grater detail, along with much more, in the [https://www.kernel.org/doc/Documentation/networking/can.txt Linux Kernel Documentation].

@@ Line 94: / Line 94: @@
 ===C Programming CAN===
 <!-- /*********************************************************************************************************/ -->
 <!-- /*****************************************       Examples        *****************************************/ -->

@@ Line 28: / Line 28: @@
 <!-- /*********************************************************************************************************/ -->
 {{:Templateimpl:using | initials=KY | title=EMAC CAN Interface | desc=This page describes how to use the CAN interface on EMAC boards. | project=OE 5.0 }}
-The CAN bus is able to be accessed from the command line, or using a C API on EMAC products (with CAN support).
+The CAN bus is able to be accessed from the command line, or using a C library on EMAC products (with CAN support).
 ===CAN Bus Setup===
-Before using the CAN interface on an EMAC device, two commands must be run. These commands could be scripted to be run at startup.
+Before using the CAN interface on an EMAC device, two commands must be run. These commands could be scripted to be run at startup, see [[EMAC_OE_Boot_Process_Customization|this page]] for details.
 {{note|The settings in the first command may need to be changed according to the application in question.}}
@@ Line 50: / Line 50: @@
 {{cli | cansend can0 0xBE 0x42 0xEF 0x9A | hostname=ipac9x25}}
 The received message, on a board running <code>candump</code>, will look like the following:
-{{clop}}<0x001> [4] be 42 ef 9a {{closp}}
+{{clo}}
 <code>cansend</code> uses, by default, an identifier of <code>0x01</code>. If an identifier other than default, the <code>-i 0x<IDENT></code> option must be passed on the command line. In the following example, the identity <code>0x89</code> is used.
@@ Line 56: / Line 58: @@
 {{cli | cansend can0 -i 0x89 0xBE 0x42 0xEF 0x9A | hostname=ipac9x25}}
 The received message, on a board running <code>candump</code>, will look like the following:
-{{clop}}<0x089> [4] be 42 ef 9a {{closp}}
+{{clo}}
 Using the standard identity, the length of the identity is limited to a maximum hexadecimal value of <code>0x7FF</code>. If a larger identity is needed, the <code>-e</code> option can be passed, which allows an extended CAN frame with a maximum hexadecimal value of <code>0x1FFFFFFF</code>. The following example shows a message with an extended frame.
@@ Line 63: / Line 67: @@
 {{cli | cansend can0 -e -i 0x8008 0xBE 0x42 0xEF 0x9A | hostname=ipac9x25}}
 The received message, on a board running <code>candump</code>, will look like the following:
-{{clop}}<0x00008008> [4] be 42 ef 9a{{closp}}
+{{clo}}
 ====candump====
 <!-- /*********************************************************************************************************/ -->
 <!-- /*****************************************       Examples        *****************************************/ -->
@@ Line 74: / Line 103: @@
 <!-- /*********************************************************************************************************/ -->
 {{:Templateimpl:conclusion | initials=KY | title=EMAC CAN Interface | desc=This page describes how to use the CAN interface on EMAC boards. | project=OE 5.0 }}
+CAN is a useful protocol for communicating quickly with sensors and other controllers. EMAC boards with CAN should be able to quickly integrate with existing CAN networks with little trouble.
 <!-- /*********************************************************************************************************/ -->
 <!-- /******************************************   More Information   *****************************************/ -->
 <!-- /*********************************************************************************************************/ -->
 {{:Templateimpl:moreinfo | initials=KY | title=EMAC CAN Interface | desc=This page describes how to use the CAN interface on EMAC boards. | project=OE 5.0 }}
+* [[Getting_Started_with_the_EMAC_OE_SDK|Getting started with the EMAC SDK]]
 {{:Templateimpl:whatnext | initials=KY | title=EMAC CAN Interface | desc=This page describes how to use the CAN interface on EMAC boards. | project=OE 5.0 }}
+* [[EMAC_HW|EMAC Hardware]]

@@ Line 44: / Line 44: @@
 * <code>cansend</code>
 * <code>cansequence</code>
-Of these five, the most used are <code>cansend</code> and <code>candump</code>.
+Of these five, the most easily used are <code>cansend</code> and <code>candump</code>.
 <!-- /*********************************************************************************************************/ -->
 <!-- /*****************************************       Examples        *****************************************/ -->