STM32F407VG CAN - Revision history

Ikramer at 17:52, 12 March 2024

2024-03-12T17:52:34Z

← Older revision		Revision as of 17:52, 12 March 2024
Line 75:		Line 75:
	=== Filter and masks ===		=== Filter and masks ===
	Out of the box every filter is set to zero, so every message is accepted. Therefore it is possible to sniff the traffic which occurs in the systems. To reduce the load on single CAN nodes one can adjust the filters and masks with the <code>MCP2515_WriteByteSequence()</code> command where the corresponding registers and values that are required should be passed. These can be looked up [https://ww1.microchip.com/downloads/aemDocuments/documents/APID/ProductDocuments/DataSheets/MCP2515-Family-Data-Sheet-DS20001801K.pdf in this datasheet]		Out of the box every filter is set to zero, so every message is accepted. Therefore it is possible to sniff the traffic which occurs in the systems. To reduce the load on single CAN nodes one can adjust the filters and masks with the <code>MCP2515_WriteByteSequence()</code> command where the corresponding registers and values that are required should be passed. These can be looked up [https://ww1.microchip.com/downloads/aemDocuments/documents/APID/ProductDocuments/DataSheets/MCP2515-Family-Data-Sheet-DS20001801K.pdf in this datasheet]



			[[Category:Documentation]]

SNenning at 20:14, 25 January 2024

2024-01-25T20:14:03Z

← Older revision		Revision as of 20:14, 25 January 2024
Line 1:		Line 1:
	== Summary ==
			== Summary ==
	This document shall provide the reader with a concise overview of how to access, read, and inject messages into an existing CAN system. In this process, an MCP 2515 CAN Controller is utilized in conjunction with an STM32F407G-DISC1 Microcontroller. It is noteworthy that any microcontroller with SPI capabilities can be used for this purpose.		This document shall provide the reader with a concise overview of how to access, read, and inject messages into an existing CAN system. In this process, an MCP 2515 CAN Controller is utilized in conjunction with an STM32F407G-DISC1 Microcontroller. It is noteworthy that any microcontroller with SPI capabilities can be used for this purpose.

Line 16:		Line 17:
	[[File:CubeMX.PNG\|800px\|thumb\|right]]		[[File:CubeMX.PNG\|800px\|thumb\|right]]
	STM32CubeMX simplifies peripheral configuration, generates initialization code, and visualizes pinouts. It eases USB stack integration, a valuable feature for projects involving USB communication. While not mandatory, CubeMX streamlines hardware and middleware setup, saving time and minimizing errors.		STM32CubeMX simplifies peripheral configuration, generates initialization code, and visualizes pinouts. It eases USB stack integration, a valuable feature for projects involving USB communication. While not mandatory, CubeMX streamlines hardware and middleware setup, saving time and minimizing errors.


	Peripheral Activation:		Peripheral Activation:

	1. Navigate to the "Connectivity" tab.		Navigate to the "Connectivity" tab.
	Activate the SPI peripheral under the specific SPI configuration that corresponds to your project.		Activate the SPI peripheral under the specific SPI configuration that corresponds to your project.
			SPI Baud Rate and Configuration:

			Within the selected SPI configuration, locate the baud rate setting.
	~~SPI Baud Rate and Configuration:~~

	2. Within the selected SPI configuration, locate the baud rate setting.
	Set the baud rate to a maximum of 10 Mbps, adhering to the MCP2515's limit.		Set the baud rate to a maximum of 10 Mbps, adhering to the MCP2515's limit.
	Confirm the CPOL (Clock Polarity) and CPHA (Clock Phase) configurations, selecting either CPOL low and CPHA 1 edge or CPOL high and CPHA 2 edges.		Confirm the CPOL (Clock Polarity) and CPHA (Clock Phase) configurations, selecting either CPOL low and CPHA 1 edge or CPOL high and CPHA 2 edges.

	~~3. Check for a "Data Configuration" tab within the SPI settings.~~
	~~Set the data size to 8 bits with MSB (Most Significant Bit) first.~~

			Check for a "Data Configuration" tab within the SPI settings.
			Set the data size to 8 bits with MSB (Most Significant Bit) first.

	USB Middleware Integration:		USB Middleware Integration:

	4. Navigate to the "Connectivity" tab.		Navigate to the "Connectivity" tab.
	Access the "USB_OTG_FS" configuration.		Access the "USB_OTG_FS" configuration.
	Set the USB mode specifically to "Device only."		Set the USB mode specifically to "Device only."


	USB Middleware Configuration:		USB Middleware Configuration:

	5. Navigate to the "Middleware" tab.		Navigate to the "Middleware" tab.
	Configure the USB middleware settings under "USB_DEVICE."		Configure the USB middleware settings under "USB_DEVICE."
	Select the exact class required, such as "Class for FS IP Virtual Port Com."		Select the exact class required, such as "Class for FS IP Virtual Port Com."


	By following these precise steps in your development environment, you can efficiently configure the SPI and USB settings for your STM32 microcontroller project.		By following these precise steps in your development environment, you can efficiently configure the SPI and USB settings for your STM32 microcontroller project.

Line 57:		Line 50:
	The wiring can be done as shown in figure but is dependent on the configured pins. It is important to connect the MOSI pin on the microcontroller to the SI pin of the CAN controller. Same goes for the MISO and SO pin. The interrupt pin can be neglected.		The wiring can be done as shown in figure but is dependent on the configured pins. It is important to connect the MOSI pin on the microcontroller to the SI pin of the CAN controller. Same goes for the MISO and SO pin. The interrupt pin can be neglected.

	== Code ==		== Code ==
	The basis of this implementation is the standard device driver from Microchip Technology Inc., accessible [https://www.microchip.com/en-us/product/MCP2515#document-table here]. This driver has been further adjusted and made compatible with a standard C library by [https://github.com/eziya/STM32_SPI_MCP2515 this GitHub repository]. To use this code, it is necessary to initialize the driver with the <code>CANSPI_Initialize()</code> function. Following this, messages can be read using the <code>CANSPI_Receive(&rxMessage)</code> function, which automatically checks the two receiver buffers and retrieves the values from them. If one intends to transmit a message, it can be achieved by utilizing the <code> CANSPI_Transmit(&txMessage)</code> function, which takes a buffer loaded with a pre-assembled message. This message frame should look like this:		The basis of this implementation is the standard device driver from Microchip Technology Inc., accessible [https://www.microchip.com/en-us/product/MCP2515#document-table here]. This driver has been further adjusted and made compatible with a standard C library by [https://github.com/eziya/STM32_SPI_MCP2515 this GitHub repository]. To use this code, it is necessary to initialize the driver with the <code>CANSPI_Initialize()</code> function. Following this, messages can be read using the <code>CANSPI_Receive(&rxMessage)</code> function, which automatically checks the two receiver buffers and retrieves the values from them. If one intends to transmit a message, it can be achieved by utilizing the <code>CANSPI_Transmit(&txMessage)</code> function, which takes a buffer loaded with a pre-assembled message. This message frame should look like this:

	<pre>		<pre>
Line 80:		Line 73:
	} uCAN_MSG		} uCAN_MSG
	</pre>		</pre>

	=== Filter and masks ===		=== Filter and masks ===
	Out of the box every filter is set to zero, so every message is accepted. Therefore it is possible to sniff the traffic which occurs in the systems. To reduce the load on single CAN nodes one can adjust the filters and masks with the <code>MCP2515_WriteByteSequence()</code> command where the corresponding registers and values that are required should be passed. These can be looked up [https://ww1.microchip.com/downloads/aemDocuments/documents/APID/ProductDocuments/DataSheets/MCP2515-Family-Data-Sheet-DS20001801K.pdf in this datasheet]		Out of the box every filter is set to zero, so every message is accepted. Therefore it is possible to sniff the traffic which occurs in the systems. To reduce the load on single CAN nodes one can adjust the filters and masks with the <code>MCP2515_WriteByteSequence()</code> command where the corresponding registers and values that are required should be passed. These can be looked up [https://ww1.microchip.com/downloads/aemDocuments/documents/APID/ProductDocuments/DataSheets/MCP2515-Family-Data-Sheet-DS20001801K.pdf in this datasheet]

SNenning at 20:00, 25 January 2024

2024-01-25T20:00:14Z

← Older revision		Revision as of 20:00, 25 January 2024
Line 82:		Line 82:

	=== Filter and masks ===		=== Filter and masks ===
	Out of the box every filter is set to zero, so every message is accepted. Therefore it is possible to sniff the traffic which occurs in the systems. To reduce the load on single CAN nodes one can adjust the filters and masks with the <code>MCP2515_WriteByteSequence()</code> command where the corresponding registers and values that are required should be passed. These can be looked up [ ~~here~~]		Out of the box every filter is set to zero, so every message is accepted. Therefore it is possible to sniff the traffic which occurs in the systems. To reduce the load on single CAN nodes one can adjust the filters and masks with the <code>MCP2515_WriteByteSequence()</code> command where the corresponding registers and values that are required should be passed. These can be looked up [https://ww1.microchip.com/downloads/aemDocuments/documents/APID/ProductDocuments/DataSheets/MCP2515-Family-Data-Sheet-DS20001801K.pdf in this datasheet]

SNenning at 19:59, 25 January 2024

2024-01-25T19:59:14Z

← Older revision		Revision as of 19:59, 25 January 2024
Line 80:		Line 80:
	} uCAN_MSG		} uCAN_MSG
	</pre>		</pre>

			=== Filter and masks ===
			Out of the box every filter is set to zero, so every message is accepted. Therefore it is possible to sniff the traffic which occurs in the systems. To reduce the load on single CAN nodes one can adjust the filters and masks with the <code>MCP2515_WriteByteSequence()</code> command where the corresponding registers and values that are required should be passed. These can be looked up [ here]

SNenning at 19:53, 25 January 2024

2024-01-25T19:53:48Z

← Older revision		Revision as of 19:53, 25 January 2024
Line 79:		Line 79:
	uint8_t array[14];		uint8_t array[14];
	} uCAN_MSG		} uCAN_MSG
	<\pre>		</pre>

	~~Blubb~~

SNenning at 19:53, 25 January 2024

2024-01-25T19:53:07Z

← Older revision		Revision as of 19:53, 25 January 2024
Line 60:		Line 60:
	The basis of this implementation is the standard device driver from Microchip Technology Inc., accessible [https://www.microchip.com/en-us/product/MCP2515#document-table here]. This driver has been further adjusted and made compatible with a standard C library by [https://github.com/eziya/STM32_SPI_MCP2515 this GitHub repository]. To use this code, it is necessary to initialize the driver with the <code>CANSPI_Initialize()</code> function. Following this, messages can be read using the <code>CANSPI_Receive(&rxMessage)</code> function, which automatically checks the two receiver buffers and retrieves the values from them. If one intends to transmit a message, it can be achieved by utilizing the <code> CANSPI_Transmit(&txMessage)</code> function, which takes a buffer loaded with a pre-assembled message. This message frame should look like this:		The basis of this implementation is the standard device driver from Microchip Technology Inc., accessible [https://www.microchip.com/en-us/product/MCP2515#document-table here]. This driver has been further adjusted and made compatible with a standard C library by [https://github.com/eziya/STM32_SPI_MCP2515 this GitHub repository]. To use this code, it is necessary to initialize the driver with the <code>CANSPI_Initialize()</code> function. Following this, messages can be read using the <code>CANSPI_Receive(&rxMessage)</code> function, which automatically checks the two receiver buffers and retrieves the values from them. If one intends to transmit a message, it can be achieved by utilizing the <code> CANSPI_Transmit(&txMessage)</code> function, which takes a buffer loaded with a pre-assembled message. This message frame should look like this:

	~~'''~~typedef union		<pre>
			typedef union
	{		{
	struct		struct
Line 77:		Line 78:
	} frame;		} frame;
	uint8_t array[14];		uint8_t array[14];
	} uCAN_MSG~~'''~~		} uCAN_MSG
			<\pre>

	Blubb		Blubb

SNenning at 19:52, 25 January 2024

2024-01-25T19:52:47Z

← Older revision		Revision as of 19:52, 25 January 2024
Line 60:		Line 60:
	The basis of this implementation is the standard device driver from Microchip Technology Inc., accessible [https://www.microchip.com/en-us/product/MCP2515#document-table here]. This driver has been further adjusted and made compatible with a standard C library by [https://github.com/eziya/STM32_SPI_MCP2515 this GitHub repository]. To use this code, it is necessary to initialize the driver with the <code>CANSPI_Initialize()</code> function. Following this, messages can be read using the <code>CANSPI_Receive(&rxMessage)</code> function, which automatically checks the two receiver buffers and retrieves the values from them. If one intends to transmit a message, it can be achieved by utilizing the <code> CANSPI_Transmit(&txMessage)</code> function, which takes a buffer loaded with a pre-assembled message. This message frame should look like this:		The basis of this implementation is the standard device driver from Microchip Technology Inc., accessible [https://www.microchip.com/en-us/product/MCP2515#document-table here]. This driver has been further adjusted and made compatible with a standard C library by [https://github.com/eziya/STM32_SPI_MCP2515 this GitHub repository]. To use this code, it is necessary to initialize the driver with the <code>CANSPI_Initialize()</code> function. Following this, messages can be read using the <code>CANSPI_Receive(&rxMessage)</code> function, which automatically checks the two receiver buffers and retrieves the values from them. If one intends to transmit a message, it can be achieved by utilizing the <code> CANSPI_Transmit(&txMessage)</code> function, which takes a buffer loaded with a pre-assembled message. This message frame should look like this:

	'''typedef union~~'''~~		'''typedef union
	{		{
	struct		struct
Line 77:		Line 77:
	} frame;		} frame;
	uint8_t array[14];		uint8_t array[14];
	} uCAN_MSG		} uCAN_MSG'''


	Blubb		Blubb

SNenning at 19:52, 25 January 2024

2024-01-25T19:52:00Z

← Older revision		Revision as of 19:52, 25 January 2024
Line 59:		Line 59:
	== Code ==		== Code ==
	The basis of this implementation is the standard device driver from Microchip Technology Inc., accessible [https://www.microchip.com/en-us/product/MCP2515#document-table here]. This driver has been further adjusted and made compatible with a standard C library by [https://github.com/eziya/STM32_SPI_MCP2515 this GitHub repository]. To use this code, it is necessary to initialize the driver with the <code>CANSPI_Initialize()</code> function. Following this, messages can be read using the <code>CANSPI_Receive(&rxMessage)</code> function, which automatically checks the two receiver buffers and retrieves the values from them. If one intends to transmit a message, it can be achieved by utilizing the <code> CANSPI_Transmit(&txMessage)</code> function, which takes a buffer loaded with a pre-assembled message. This message frame should look like this:		The basis of this implementation is the standard device driver from Microchip Technology Inc., accessible [https://www.microchip.com/en-us/product/MCP2515#document-table here]. This driver has been further adjusted and made compatible with a standard C library by [https://github.com/eziya/STM32_SPI_MCP2515 this GitHub repository]. To use this code, it is necessary to initialize the driver with the <code>CANSPI_Initialize()</code> function. Following this, messages can be read using the <code>CANSPI_Receive(&rxMessage)</code> function, which automatically checks the two receiver buffers and retrieves the values from them. If one intends to transmit a message, it can be achieved by utilizing the <code> CANSPI_Transmit(&txMessage)</code> function, which takes a buffer loaded with a pre-assembled message. This message frame should look like this:
	~~<code>~~

	typedef union		'''typedef union'''
	{		{
	struct		struct
Line 81:		Line 80:


	~~<\code>~~
	Blubb		Blubb

SNenning at 19:50, 25 January 2024

2024-01-25T19:50:47Z

← Older revision		Revision as of 19:50, 25 January 2024
Line 59:		Line 59:
	== Code ==		== Code ==
	The basis of this implementation is the standard device driver from Microchip Technology Inc., accessible [https://www.microchip.com/en-us/product/MCP2515#document-table here]. This driver has been further adjusted and made compatible with a standard C library by [https://github.com/eziya/STM32_SPI_MCP2515 this GitHub repository]. To use this code, it is necessary to initialize the driver with the <code>CANSPI_Initialize()</code> function. Following this, messages can be read using the <code>CANSPI_Receive(&rxMessage)</code> function, which automatically checks the two receiver buffers and retrieves the values from them. If one intends to transmit a message, it can be achieved by utilizing the <code> CANSPI_Transmit(&txMessage)</code> function, which takes a buffer loaded with a pre-assembled message. This message frame should look like this:		The basis of this implementation is the standard device driver from Microchip Technology Inc., accessible [https://www.microchip.com/en-us/product/MCP2515#document-table here]. This driver has been further adjusted and made compatible with a standard C library by [https://github.com/eziya/STM32_SPI_MCP2515 this GitHub repository]. To use this code, it is necessary to initialize the driver with the <code>CANSPI_Initialize()</code> function. Following this, messages can be read using the <code>CANSPI_Receive(&rxMessage)</code> function, which automatically checks the two receiver buffers and retrieves the values from them. If one intends to transmit a message, it can be achieved by utilizing the <code> CANSPI_Transmit(&txMessage)</code> function, which takes a buffer loaded with a pre-assembled message. This message frame should look like this:
			<code>

	typedef union		typedef union
Line 80:		Line 80:
	} uCAN_MSG		} uCAN_MSG


			<\code>
	Blubb		Blubb

SNenning at 19:50, 25 January 2024

2024-01-25T19:50:21Z

← Older revision		Revision as of 19:50, 25 January 2024
Line 61:		Line 61:


	{typedef union		typedef union
	{		{
	struct		struct
Line 78:		Line 78:
	} frame;		} frame;
	uint8_t array[14];		uint8_t array[14];
	} uCAN_MSG;}		} uCAN_MSG

	Blubb		Blubb