Engineered for high-speed excellence, our CAN FD transceiver delivers unmatched performance in automotive and industrial systems
A
A
Hardware Overview
How does it work?
CAN FD 6 Click is based on the TCAN4550, a CAN transceiver that supports CAN and CAN FD protocols and provides an interface between the CAN bus and the CAN protocol controller up to 5 megabits per second (Mbps) from Texas Instruments. It is characterized by high-bandwidth and data-rate flexibility, provides an SPI interface between the CAN bus and the system processor, and supports wake-up features local and bus wake using the CAN bus. The device includes many protection features providing CAN bus robustness, including fail-safe mode, internal dominant state timeout, and wide bus operating range. The TCAN4550 has one pin for waking the device from Sleep mode. This pin is connected to an external button labeled WAKE and the PWM pin of the mikroBUS™ socket labeled WKP to generate a local Wake-Up function. A Wake-Up event on the CAN bus switches the inhibit output pin INH to the high level. The INH pin provides an internal switch towards the battery supply voltage and controls external voltage regulators, the MCP1804 from
Microchip. Through SMD jumpers labeled as 3V3JMP and 5VJMP, the LDO's output voltages can power up the mikroBUS™ 3.3V and 5V power rails. However, it should be noted that Mikroe does not advise powering up their systems this way. That is why these jumpers are left unpopulated by default. CAN FD 6 Click communicates with MCU using a standard SPI interface supporting clock rates up to 18MHz to transmit and reception CAN frames. With an additional 40MHz crystal, the TCAN4550 can meet CAN FD rates up to 5 Mbps data rates to support higher data throughput and operates from a 6V to 24V external power supply header on the board's right side. This feature makes the TCAN4550 device ideal for many applications, including automotive ones. This Click board™ comes equipped with the industry-standard DB-9 connector, making interfacing with the CAN bus simple and easy. Besides, the user can connect the CAN signals directly through the CAN External header on the board's left edge. In addition to these features, the TCAN4550 uses
several GPIO pins connected to the mikroBUS™ socket. The RST pin, the mikroBUS™, can perform the Hardware Reset function, which resets the device to the default settings and puts it into standby mode. This feature can also be achieved through the onboard push-button labeled as RST. Next to these pins, the ATA6571 uses the WKR pin as a dedicated wake-up request pin from a bus wake request and the INT pin as an interrupt feature routed on the AN and INT pin of the mikroBUS™ socket. The user can also use GPIO pins from the header on the board's right side for interrupt purposes. This Click board™ can operate with both 3.3V and 5V logic voltage levels selected via the VIO SEL jumper. It allows both 3.3V and 5V capable MCUs to use the UART communication lines properly. However, the Click board™ comes equipped with a library containing easy-to-use functions and an example code that can be used, as a reference, for further development.
Features overview
Development board
Nucleo 32 with STM32F031K6 MCU board provides an affordable and flexible platform for experimenting with STM32 microcontrollers in 32-pin packages. Featuring Arduino™ Nano connectivity, it allows easy expansion with specialized shields, while being mbed-enabled for seamless integration with online resources. The
board includes an on-board ST-LINK/V2-1 debugger/programmer, supporting USB reenumeration with three interfaces: Virtual Com port, mass storage, and debug port. It offers a flexible power supply through either USB VBUS or an external source. Additionally, it includes three LEDs (LD1 for USB communication, LD2 for power,
and LD3 as a user LED) and a reset push button. The STM32 Nucleo-32 board is supported by various Integrated Development Environments (IDEs) such as IAR™, Keil®, and GCC-based IDEs like AC6 SW4STM32, making it a versatile tool for developers.
Microcontroller Overview
MCU Card / MCU
Architecture
ARM Cortex-M0
MCU Memory (KB)
32
Silicon Vendor
STMicroelectronics
Pin count
32
RAM (Bytes)
4096
You complete me!
Accessories
Click Shield for Nucleo-32 is the perfect way to expand your development board's functionalities with STM32 Nucleo-32 pinout. The Click Shield for Nucleo-32 provides two mikroBUS™ sockets to add any functionality from our ever-growing range of Click boards™. We are fully stocked with everything, from sensors and WiFi transceivers to motor control and audio amplifiers. The Click Shield for Nucleo-32 is compatible with the STM32 Nucleo-32 board, providing an affordable and flexible way for users to try out new ideas and quickly create prototypes with any STM32 microcontrollers, choosing from the various combinations of performance, power consumption, and features. The STM32 Nucleo-32 boards do not require any separate probe as they integrate the ST-LINK/V2-1 debugger/programmer and come with the STM32 comprehensive software HAL library and various packaged software examples. This development platform provides users with an effortless and common way to combine the STM32 Nucleo-32 footprint compatible board with their favorite Click boards™ in their upcoming projects.
DB9 Cable Female-to-Female (2m) cable is essential for establishing dependable serial data connections between devices. With its DB9 female connectors on both ends, this cable enables a seamless link between various equipment, such as computers, routers, switches, and other serial devices. Measuring 2 meters in length, it offers flexibility in arranging your setup without compromising data transmission quality. Crafted with precision, this cable ensures consistent and reliable data exchange, making it suitable for industrial applications, office environments, and home setups. Whether configuring networking equipment, accessing console ports, or utilizing serial peripherals, this cable's durable construction and robust connectors guarantee a stable connection. Simplify your data communication needs with the 2m DB9 female-to-female cable, an efficient solution designed to meet your serial connectivity requirements easily and efficiently.
Used MCU Pins
mikroBUS™ mapper
Take a closer look
Schematic
Step by step
Project assembly
Track your results in real time
Application Output
After loading the code example, pressing the "DEBUG" button builds and programs it on the selected setup.
After programming is completed, a header with buttons for various actions available in the IDE appears. By clicking the green "PLAY "button, we start reading the results achieved with Click board™.
Upon completion of programming, the Application Output tab is automatically opened, where the achieved result can be read. In case of an inability to perform the Debug function, check if a proper connection between the MCU used by the setup and the CODEGRIP programmer has been established. A detailed explanation of the CODEGRIP-board connection can be found in the CODEGRIP User Manual. Please find it in the RESOURCES section.
Software Support
Library Description
This library contains API for CAN FD 6 Click driver.
Key functions:
canfd6_mcan_write_txbuffer
- This function will write a CAN message to a specified TX buffer that can be transmitted at a later time with the transmit buffer contents functioncanfd6_mcan_transmit_buffer_contents
- This function writes the specified buffer index bit value into the TXBAR register to request a message to sendcanfd6_mcan_read_nextfifo
- This function will read the next MCAN FIFO element specified and return the corresponding header information and data payload.
Open Source
Code example
This example can be found in NECTO Studio. Feel free to download the code, or you can copy the code below.
/*!
* @file main.c
* @brief CANFD6 Click example
*
* # Description
* This application presents the capabilities of the
* CAN FD 6 click board. The board can be used both
* as a receiver and a transmitter. Use def directive
* to define the receive or transmit app.
*
* The demo application is composed of two sections :
*
* ## Application Init
* The app starts by initializing the UART LOG and
* SPI drivers. The default cfg function performs the
* mandatory settings of the device. The user's default
* configuration can be modified ( for more information
* about device configuration, check the datasheet ).
* Additionally, the app writes two messages to the FIFO
* buffer and sends them if the transmit buffer content
* event is triggered.
*
* ## Application Task
* Depending on the defined app option, the application
* task performs the following procedure. If the transmitter
* is preferred, the application task triggers the transmit
* buffer contents event of the first message and, later on,
* the second message. On the other hand, the receiver waits
* for the CAN FD interrupt, where the payload is read along
* with the header ID.
*
* @author Stefan Nikolic
*
*/
#include "board.h"
#include "log.h"
#include "canfd6.h"
// Comment out the line below in order to switch the application mode to receiver
#define DEMO_APP_TRANSMITTER
#define CANFD6_FIRST_MSG 0
#define CANFD6_SECOND_MSG 1
static canfd6_t canfd6;
static log_t logger;
void application_init ( void ) {
log_cfg_t log_cfg; /**< Logger config object. */
canfd6_cfg_t canfd6_cfg; /**< Click config object. */
/**
* Logger initialization.
* Default baud rate: 115200
* Default log level: LOG_LEVEL_DEBUG
* @note If USB_UART_RX and USB_UART_TX
* are defined as HAL_PIN_NC, you will
* need to define them manually for log to work.
* See @b LOG_MAP_USB_UART macro definition for detailed explanation.
*/
LOG_MAP_USB_UART( log_cfg );
log_init( &logger, &log_cfg );
log_info( &logger, " Application Init " );
// Click initialization.
canfd6_cfg_setup( &canfd6_cfg );
CANFD6_MAP_MIKROBUS( canfd6_cfg, MIKROBUS_1 );
err_t init_flag = canfd6_init( &canfd6, &canfd6_cfg );
if ( init_flag == SPI_MASTER_ERROR ) {
log_error( &logger, " Application Init Error. " );
log_info( &logger, " Please, run program again... " );
for ( ; ; );
}
canfd6_default_cfg( &canfd6 );
Delay_ms( 100 );
#ifdef DEMO_APP_TRANSMITTER
canfd6_mcan_tx_header_t canfd6_header = { 0 };
uint8_t data_send_buf[ 64 ] = { 0 };
strcpy ( data_send_buf, "MIKROE" );
canfd6_header.DLC = CANFD6_MCAN_DLC_6B;
canfd6_header.ID = 0x123;
canfd6_header.FDF = 1;
canfd6_header.BRS = 1;
canfd6_header.EFC = 0;
canfd6_header.MM = 0;
canfd6_header.RTR = 0;
canfd6_header.XTD = 0;
canfd6_header.ESI = 0;
canfd6_mcan_write_txbuffer( &canfd6, CANFD6_FIRST_MSG, &canfd6_header, data_send_buf );
strcpy ( data_send_buf, "CAN FD 6 click board" );
canfd6_header.DLC = CANFD6_MCAN_DLC_20B;
canfd6_header.ID = 0x456;
canfd6_header.FDF = 1;
canfd6_header.BRS = 1;
canfd6_header.EFC = 0;
canfd6_header.MM = 0;
canfd6_header.RTR = 0;
canfd6_header.XTD = 0;
canfd6_header.ESI = 0;
canfd6_mcan_write_txbuffer( &canfd6, CANFD6_SECOND_MSG, &canfd6_header, data_send_buf );
log_printf( &logger, " Application Mode: Transmitter\r\n" );
#else
log_printf( &logger, " Application Mode: Receiver\r\n" );
#endif
log_info( &logger, " Application Task " );
}
void application_task ( void ) {
#ifdef DEMO_APP_TRANSMITTER
log_printf( &logger, " Transmit first message\r\n" );
canfd6_mcan_transmit_buffer_contents( &canfd6, CANFD6_FIRST_MSG );
Delay_ms( 2000 );
log_printf( &logger, " Transmit second message\r\n" );
canfd6_mcan_transmit_buffer_contents( &canfd6, CANFD6_SECOND_MSG );
Delay_ms( 2000 );
#else
uint8_t cnt = 0;
if ( !canfd6_get_int_pin( &canfd6 ) ) {
canfd6_device_interrupts_t canfd6_dev_ir = { 0 };
canfd6_mcan_interrupts_t canfd6_mcan_ir = { 0 };
canfd6_device_read_interrupts( &canfd6, &canfd6_dev_ir );
canfd6_mcan_read_interrupts( &canfd6, &canfd6_mcan_ir );
if ( canfd6_dev_ir.SPIERR ) {
canfd6_device_clear_spierr( &canfd6 );
}
if ( canfd6_mcan_ir.RF0N ) {
canfd6_mcan_rx_header_t canfd6_msg_header = { 0 };
uint8_t num_bytes = 0;
uint8_t data_payload[ 64 ] = { 0 };
canfd6_mcan_clear_interrupts( &canfd6, &canfd6_mcan_ir );
num_bytes = canfd6_mcan_read_nextfifo( &canfd6, CANFD6_RXFIFO0, &canfd6_msg_header, data_payload );
log_printf( &logger, " Message received ID[ 0x%X ]: ", canfd6_msg_header.ID );
while ( cnt < 64 ) {
if ( data_payload[ cnt ] ) {
log_printf( &logger, "%c", data_payload[ cnt ] );
cnt++;
} else {
log_printf( &logger, "\r\n" );
cnt = 64;
}
}
}
}
#endif
}
void main ( void ) {
application_init( );
for ( ; ; ) {
application_task( );
}
}
// ------------------------------------------------------------------------ END