Over 10 years we help companies reach their financial and branding goals. Engitech is a values-driven technology agency dedicated.

Gallery

Contacts

411 University St, Seattle, USA

engitech@oceanthemes.net

+1 -800-456-478-23

Automotive Protocols

CAN Controller in Embedded

Introduction

In this blog, we will delve into the CAN protocol in embedded systems. Our goal is to gain a comprehensive understanding of the CAN protocol from the perspective of microcontrollers and embedded systems. While there is a plethora of content available online that explains the theoretical concepts of the CAN protocol, resources that focus on its practical implementation from a microcontroller and embedded systems standpoint are scarce.

It is crucial to grasp the intricacies of the CAN protocol from a microcontroller and embedded systems perspective, especially when it comes to integrating it into your product or learning about the protocol. By understanding the CAN protocol in this context, you will be better equipped to effectively implement it in your projects.

Over net and online courses, we will find number of resources and blogs about CAN protocol and technology. All of the resources cover only theoretical part of CAN protocol. Not only theoretical but rather same content is there in most of the resources. Most of the content is on what is CAN protocol and Its overview in terms of features and specs. Those resources are good to know from beginners point of view and good to have to know about CAN protocol in theoretical respect.  But resources on CAN technology implementation in practical way and how to use CAN technology for doing CAN communication is very very limited and not present.

And that what we are going to cover in today topic. We are going to understand about CAN Protocol from microcontroller and practical implementation point of view.

Brief About CAN

In CAN protocol, there are 3 types: Standard CAN, Extended CAN and CAN FD. Difference between these 3 are of size of payload data, size of message identifier and speed.

CAN communication is a 2-wire serial communication protocol. These 2 pins are termed as CAN Tx and CAN Rx pins. Every Microcontroller which is have a CAN peripheral, would be having these 2 pins. CAN protocol use these 2 pins for communication between 2 nodes via CAN technology.

CAN Protocol

CAN Protocol has 4 type of Frames:

  1. CAN Data Frame
  2. CAN Remote Frame
  3. CAN Error Frame
  4. CAN Overload Frame

CAN protocol has broadly 3 types:

  1. Standard CAN: 11-bit Message ID with 8 bytes of CAN data
  2. Extended CAN: 29-bit Message ID with 8 bytes of CAN data
  3. CAN FD: 11-bit Message ID with 8/16/32/64 bytes of CAN data.

Important Terminologies

The CAN protocol was initially developed for use as a vehicle serial data bus, addressing the specific needs for real-time processing and reliable operation in the EMI environment of a vehicle.

  1. CAN Bus
  2. CAN Signal
  3. Arbitration

CAN Standard

CAN specification was launched 1986 by Bosch and in next year 1987 first CAN controller chips were made by Intel. Then in 1991, CAN2.0 specification was launched by Bosch, which is widely accepted in automotive industry and internationally accepted for doing ECU Communication’s in a car.

CAN2.0 is specification that define the CAN protocol.  The implementation of CAN protocol to achieve its properties are defined in ISO-11898 standard. Thus, since that ISO-11898 standard series is being followed for implementing CAN protocol.

ISO-11898 is the standard that defines the CAN protocol, according to CAN2.0 specifications. There are series of ISO-11898 standards. A brief about each standard is given below. ISO-11898 has following parts: 

  1. ISO-11898-1 2003 2015 2024: Specifies Data Link Layer and Physical signaling of the CAN. This document describes the general architecture and provides the characteristics for setting up an exchange of digital data between electronic modules through CAN protocol. It specifies detail of logical link control(LLC) and medium access control (MAC) layer.
  2. ISO-11898-2 2003 2016 2024: Physical Layer for high-speed CAN for transmission rates up to 1 Mbits/s. This is first standard that specifies physical layer for CAN using 2-wire balance signaling scheme.
  3. ISO-11898-3 2006: Physical Layer for low-speed CAN for transmission rates of 40kbits/ to 125kbits/s.
  4. ISO-11898-4: specifies time triggered communication in the CAN.
  5. ISO-11898-5: Physical layer for high speed CAN for transmission rates upto 1Mbits/s. It is an extension of ISO 11898-2 dealing with new functionality for systems requiring low-power consumption features while there is no active bus communication.
  6. ISO-11898-6:2013: Physical Layer for transmission rates upto 1Mbits. It is an extension of ISO 11898-2 and ISO 11898-5 specifying a selective wake-up mechanism using configurable CAN frames.

Compared to OSI model, ISO-11898 standard has divided CAN protocol in Physical Layer and Data Link layer. We will brief about these layers after understanding about CAN node and CAN controller.

What is CAN Node?

For Doing the CAN Communication, in real world their is a CAN node. CAN node consists of:

  1. Host Microcontroller Controlling the CAN communication.
  2. CAN controller(CAN peripheral or External CAN IC)
  3. CAN transceiver IC

CAN transceiver IC followes the ISO-11898 standard2&3. These 2 ISO standards define the physical characteristics and electrical specification for doing CAN communication. While CAN Controller follows the ISO-11898-1 specification that is data link layer, which specifies how should CAN hardware handle the outgoing and incoming messages so as to achieve required properties of CAN protocol.

Host MCU: A host is a microcontroller or microprocessor which is running some application to do a specific job. A host configures and control the CAN controller for doing CAN communication. 

  1. It decides which type of CAN protocol to use( Standard/Extended/CAN FD)
  2. When to send data, when to receive data
  3. Configures how to use CAN controller( what baudrate, transmission/reception mechanism: polling:interrupt:DMA and etc)

CAN Controller: CAN controller deals with the transmission and reception of data according to CAN protocol. It also triggers the transmission, or the reception of the CAN messages. The data link layer of CAN and physical bit timing is implemented
by the CAN controller (sometimes embedded within a microcontroller or some external CAN IC), according to the CAN 2.0b specification and conforming to the data link layer portion of the ISO-11898 standard. CAN Controller has following Roles and Responsibility:

  1. Message Filtering
  2. Arbitration
  3. Message Framing
  4. error handling and detection

CAN Transceiver IC: CAN transceiver is responsible for the transmission or the reception of the data on the CAN bus. It converts the data signal into the stream of data collected from the CAN bus that the CAN controller can understand. A CAN (Controller Area Network) transceiver is an Integrated Chip that interfaces between the CAN protocol controller and the physical bus. It converts the data from the controller into a form that can be transmitted over the CAN bus and vice versa. CAN Transceiver IC has following Roles and Responsibility:

1. Signal Conversion: Converts the digital signals from the CAN controller to the differential signals required for the CAN bus, and vice versa.

2. Voltage Level Adaptation: Ensures compatibility between the logic level of the CAN controller and the voltage levels on the CAN bus.

3. Fault Tolerance: Can include features to detect and handle bus errors and collisions, ensuring reliable communication even in the presence of faults.

4. Isolation: Provides electrical isolation between the CAN controller and the bus to protect the controller from voltage spikes and other electrical anomalies on the bus.

CAN Controller

Overview

In microcontroller to use CAN technology, there is a CAN Controller which handles CAN communication and follow CAN standards of ISO-11898 to support CAN protocol and its features. CAN Controller can be of 2 types CAN peripheral in Microcontrollers or some external CAN IC. So now in this blog, we are going to dig deep into general understanding of CAN Controller which are either present in the form of CAN Peripheral in microcontroller or some External CAN IC. We are going to focus on CAN Peripheral for examples given. But same understanding would be their for External CAN IC.

In different Microcontrollers there is a CAN peripheral, that can be referenced by different names. Like in NXP S32K1 and S32K3 MCU’s it is FlexCAN Module, in Infineon Technologies TC3xx MCU it is MCMCAN module. And multiple instances of corresponding CAN peripheral, can be present in a corresponding MCU. In NXP S32K1xx there are 3 instances of FlexCAN module.  In Infineon TC3xx there are 5 instances on MCMCAN module. The peripherals can be termed as different names in different microcontroller, but their basic working and concept is same in all. So, it’s important that we understand how CAN peripheral in a microcontroller works.

Understanding the working of CAN peripheral of a microcontroller, make us get knowledge on how to use CAN technology in practical sense. Relating theoretical concepts of CAN technology like multi-bus protocol, error managmentStandard/Extended CAN Data Frames communication techniques, Transmission/Reception of different data frames of CAN  with practical DIY projects, is best done by understanding how CAN peripheral in a microcontroller works and then doing simple DIY projects to test different features of that technology.

How does CAN peripheral in microcontroller’s work for doing CAN communication? How to do simple 2-way CAN communication from microcontrollers?  How CAN transmission happens? How CAN reception happens? How to configure Microcontroller for CAN transmission and CAN reception? How to do CAN communication via different techniques(polling/interrupt/DMA)? How standard/extended/CAN FD communication configurations are done? 

In CAN peripheral there are concept of Message buffer, Mailboxes, Rx FiFo, FiFo message ID filter table and CAN protocol engine which are used for transmission and reception of CAN data. These concepts are important to understand. These concepts are implemented in CAN peripherals and external CAN ICs via which transmission and reception of CAN data frames happen at microcontroller and embedded level. However, the nature of implementations of these concepts in CAN peripherals can be different and would be SoC dependent. Understanding of this concept is important from Embedded Software point of view and if you want to have some Handson project and learning on CAN protocol.

What are Message buffers in CAN Controllers?

Well now in CAN peripheral of the microcontroller’s, there is a small section of memory in microcontroller that is being used to process the CAN data. This memory is called as message buffer. Buffer signifying for memory and message signifying for CAN data. All CAN Transmitted and received data is processed in this message buffer space only. The message buffer can be referenced as Embedded RAM or Memory RAM in different SoC. But all terminologies meant same thing.

Message_Buffer_Area

The message buffer will process all kinds of CAN Data : Standard CAN, Extended CAN, CAN FD messages. All the CAN transmission and reception of CAN data happens via the message buffer space only.

A standard CAN data is of 13.5 bytes in total, which we will near about 16 bytes to align it to 
microcontroller buses. Extended CAN data is of exact 16 bytes in total, in which 8 bytes are of
payload. Similar way in the case of CAN FD data, it occupies 16, 24, 40 or 72 bytes in total in
which 8, 16, 32, 64 bytes are payload. Though CAN FD data frames are of 14, 22, 38, 70 bytes in
total but for aligning these bytes with microcontroller busses, these are rounded off to nearest
8 multiples.
Previous slide
Next slide

Depending on size of the message buffer, more the number of CAN Messages can be transmitted and received at a time. More the Message buffer space is more the number of CAN data can be transmitted and received. Now implementation of message buffer can be different in SoC to SoC.

  1. In some SoC’s this message buffer has fixed size (NXP S32K1xx-S32K3xx MCU series, Infineon TC3xx and Renesas RH850 SoC’s): S32K144 has 512 bytes of message buffer, S32K344 has 1536 bytes of message buffer, Infineon TC3xx Microcontroller has total 4480 words of message buffer
  2. Whereas in Some SoC’s the message buffer space is designated by special CAN Peripheral registers (this is usually done in low space microcontrollers for e.g in STM32F103): STM32 series has designated registers( 7-8 registers in total) to use message buffer.

Now whenever a CAN message has to be transmitted, Microcontroller will write a CAN message Data and ID in one of the memory addresses of this message buffer, according to message buffer structure. And in the case of receiving, the external CAN message data and ID is received in this memory area if all acceptance criteria conditions are met. 

There are 2 mechanisms in Message Buffer: MailBox and FIFO for Processing CAN Data.
In the case of MailBox Mechanism, acceptance criteria is the message ID that is binded to the
mailbox. And in the case of FIFO mechanism, acceptance criteria is the Message ID filter table.
Message Buffer structure is applicable for mailboxes only, for FIFO mechanism, it has its own FIFO
structure.

 

About Mailbox in CAN Controllers.

Now number of sections in a message buffer is, equal to space of message buffer divided by CAN data frame size. Each of this section is signified by a Mailbox(also called as Message Object.) Each section of the message buffer is referenced by a integer number, which is called a mailbox number. 

MailBox_Message_Buffer

So, for address 0x00 to 0x10(16 bytes) in message buffer, it is referenced by Mailbox number 1. From 0x10 to 0x20 it will be referenced by Mailbox number 2. 0x30-0x40 -> mailbox number 3 and 0x40-0x50 -> mailbox number 4 and so on. So, we have kind of assigned a mailbox number to the different address spaces of message buffer. So, when using mailbox mechanism, their would-be linear sections of memory that are incremented according to CAN data size and each section is referenced by mailbox number.

So now if we are processing Standard CAN, Extended CAN or CAN FD with 8 bytes payload: 16 Bytes of message buffer space is what is going to be consumed for a single Data Frame, whether it is for transmission or reception. So, total there can be 32 sections of memory if we have 512-byte size of message buffer (in the case of S32K144 Microcontroller) and 96 sections of memory if we have 1536 bytes size of message buffer(In the case of S32K344 Microcontroller).

Also Depending upon the CAN payload bytes, we can have different number of mailboxes as more the payload size in a CAN frame, more size would be of overall single CAN Frame. 

As each mailbox signifies a memory of message buffer. So we can configure a mailbox to be used for transmission of CAN data or we can configure a mailbox to be used for receiving of CAN data. Thus that how via mailbox mechanism we get configuration flexibility for transmitting and receiving feature of CAN protocol achived.

MailBox Tx and Rx in message buffer

What is Mailbox in CAN Controller?

The terminology which is used to refer to one section of memory of message buffer space is Mailbox. And we can configure whether this mailbox has to be used for CAN transmission or CAN reception. In the case of CAN transmission, it would be termed as TX mailbox and in the case of CAN reception it would be termed as RX mailbox.

Mailbox_Tx&Mailbox_Rx

Data to be transmitted by Tx mailbox follows the arbitration process to transmit the data, and the external signal transmitted is received by Rx mailbox if message ID of external signal matches with the message ID of Rx Mailbox.

How Tx mailbox works?

Now mailbox signifies a section of memory in message buffer, where CAN data can be written from Microcontroller in the case of transmission. So, We can bind a section of memory or what we can call a mailbox with one CAN message ID. Whenever Microcontroller calls that mailbox, configured CAN message ID with its data content would be transmitted.

TX_MailBox

In the case of transmission there are 2 important concepts to understand. First is arbitration and second is transmit priority.

Transmit priority: We can configure multiple mailboxes with different message IDs to transmit different CAN data. Now we can configure the order of transmission of those mailboxes. Which mailbox would be transmitted first, and which would be transmitted last. The CAN Controller has this feature to configure the order of transiting mailboxes.  Via this feature of Tx Mailbox, another CAN priority of prioritization messages is achived.

Transmit Arbitration: 

How Rx mailbox works?

In the case of reception, we can bind a mailbox with a CAN message ID. And whenever a external CAN data of that message ID is received, the CAN data is copied to the memory that is being signified by mailbox.

So, say we want to receive 2 CAN data of 0x402 message ID and 0x502 message ID. So, we can assign mailbox number 4 to 0x402 and mailbox number 20 to 0x502. Whenever CAN messages of this message ID is received by MCU, the memory that is signified by corresponding mailboxes would be filled with CAN received Data.

Now in a car a single ECU receives number of CAN data. So, we have to configure new mailbox for each CAN message ID that we want to receive.

This process might feel like it gives all the nodes a ‘master importance’, but it only adds to unwanted traffic towards every module on the bus in practicality. When connected to a CAN bus, the data logger acts as another node. Logging all the traffic in the CAN bus fills up the internal storage quickly. Finally, you may end up having no storage left to log the data when the vital/required data is transmitted in the bus.

Interrupt in MailBoxes

About FiFo buffer in CAN Controller?

There is one more way to divide the sections of memory buffer. That is using FiFo buffer. What we do is we will configure a memory section of message buffer to be used as FiFo buffer.

FIFO_Buffer_MEssage_Buffer

How FiFo mechanism works?

What happens in FIFO buffer is that, a buffer is created and only that buffer space is used for receiving and transmitting the data. We don’t configure different memory sections or mailbox numbers for transmitting/receiving CAN data. So First Come First Out mechanism is implemented, which ever configured CAN data comes first would be process first further.

In the case of reception, it is called as Rx FiFO and in the case of transmission it is called Tx FiFo. In FiFo mode, we create a Message ID filter table or Message ID transmit table in message buffer memory. These tables would be stored with CAN message ID’s that should be accepted (in the case of receiving) or transmitted (in the case of transmission) by MCU. 

  • In the case of reception if external CAN signal’s message ID matches with the ID’s mentioned in Message ID filter table it will copy external CAN data into a memory section of FiFo buffer. So, it works in a FiFo mechanism, First Come first out. Whichever CAN message ID out of Message ID filter table comes first will be read first by MCU.
  • In the case of transmission, MCU will copy CAN data from message ID transmit table in configured order (ascending or descending) to the memory section of the FiFo buffer. And Can data be transmitted continuously until whole transmit message ID table is empty.
  • In FiFo mechanism, Host MCU configure a section of memory in message buffer as FiFo Buffer. And data reception and transmission will happen from this FiFo buffer only on the basis of First in First Out. Whichever message Id is detected first would be processed first by MCU.

FIFO Buffer implementation

FiFo working mechanism is also implementation specific. In Some controller’s only Rx FiFo is available (NXP S32K1xx and NXP S32K3xx) and no TX FiFo. While in some controller both Tx and Rx FiFo will be available(Infineon TC3xx MCU’s),

FiFo buffer implementation is different from SoC to SoC. In some SoC’s FiFo buffer have different memory space with in message buffer and mailboxes have different memory space in message buffer (Infineon TC3xx MCU’s), while in some SoC’s FiFo buffer and mailboxes lies on same message buffer space ( NXP S32K1xx and S32K3xx)

In first case, enabling the RX FiFo decreases the count of mailboxes that are available to use for Tx/Rx mailbox mechanism. In First case, Rx FiFo and mailboxes reside in different memory space. But this is usually possible in those SoC’s which have larger memory. Second stage is what is used in small memory size MCU’s.

Previous slide
Next slide

Let’s understand FiFo mechanism from receiving perspective. As FiFo mechanism is mainly for receiving of CAN Data. In this mechanism, we configure which all message ID’s we want to receive in FiFo buffer via Message ID filter Table. If any of the external CAN signal message ID, matches with the message ID of filter table the CAN data is written into the FiFo Buffer.

Message_ID_Filter_table_FIFO_BUffer

Host Microcontroller has to read the CAN data from the FIFO buffer memory space. FIFO buffer is x message deep. This x varies in different CAN peripherals and CAN IC’s.  It can store up-to x messages in its buffer and HOST MCU can read the data sequentially in the order it is received. If MCU doesn’t read the data, then corresponding error flags would be raised by FiFo engine. Those 2 are watermark and overflow error.

  • Watermark error is raised when FIFO buffer is almost full, indicating to HOST MCU that it should read the data from FIFO, FIFO buffer is almost full.
  • Overflow error is raised, when FIFO buffer is full and again new CAN data is received by FIFO. When Overflow error is raised, new data will be overwritten by first data that was received and it will be lost. As FIFO buffer is full, so it will start overwriting the new CAN Data.

What is Message ID filter table?

This is a memory space in memory buffer created when we use FIFO mechanism. Over here Host MCU write’s the Message ID’s that should be accepted by FIFO Buffer. Message ID filter table is given a name table, as over here we can list down message IDs according to acceptance criteria type that should be accepted by FIFO Buffer.

Message_ID_Filter_table

In a single row of the table 1 acceptance criteria is written. So more the number of rows a greater number of message ID’s can be filtered. During Rx FiFo mechanism, CAN messages are received according to Message ID filter table. Only those message ID’s which are mentioned in message ID filter table would be received. All other message ID’s would be discarded from a corresponding CAN node.

message_id_filter_table_mailbox_new

The implementation of message ID filter is also different in SoC to SoC. In some controller’s Message ID filter table is in same memory area of message buffer where mailboxes are present. So in those increasing the Message ID filter table rows, reduces the MailBoxes number available for application. In some SoC, Message ID filter table is at different memory area of message buffer then mailboxes. So, increasing the Message ID filter table rows, doesn’t impact the mailboxes numbers.

What are Acceptance criteria?

Acceptance criteria in CAN is powerful filtering scheme to accept only frames intended for the target application. We can Configure which frames to accept in FIFO mechanism by mentioning the message IDs in the Message ID Filter Table. Message IDs of Standard CAN, Extended CAN or CAN FD, all of these are supported.

Acceptance criteria can be of 3 types:

  1. Single Acceptance criteria
  2. Dual Acceptance Criteria
  3. Range of Message ID criteria

In a single acceptance criterion, we can mention 1 message ID per index of filter table that should be accepted. This is simplest form of acceptance criteria. In Dual Acceptance criteria, we can mention 2 message ID per index of filter table that should be accepted. In range of message ID, we can mention a range of message ID’s that should be accepted.

But different SoC’s can have different formats of acceptance criteria. In some SoC’s we can write up to 2 Standard message ID in one acceptance criteria. Acceptance criteria also have features of bit mast, which makes it possible to configure a range of message ID to be accepted. Main moto of acceptance criteria is to provide a powerful filtering scheme, though its implementation and features can vary from SoC to SoC. Use the acceptance criteria and filter table, we can configure a CAN node to receive number of CAN data based on different message IDs.

Today’s vehicles can contain more than 70 devices, commonly called Electronic Control Units (ECUs) or nodes, that control electrical subsystems. These subsystems control the engine, transmission, powertrain and antilock braking/ABS along with many more. Communication between these subsystems is critical to ensure the reliability and safety demanded in the automotive market. The acceptance criteria feature of Controller Area Network allows ECUs to communicate within a vehicle, with each other by assigning different message IDs. We can assign every ECU with a designated Message ID and then configure other ECUs with this message ID, as a acceptance criteria so as to accept its data.

FIFO Mechanism in CAN Controller achives the Multicast reception, multi master and system wide data consistency features of CAN protocol.

CAN Properties

Well so as if now, you guys must have got the good kind of clarity and understanding in terms of CAN protocol implementation in microcontroller and embedded world. Now let’s just conclude that how does this implementation fulfills the CAN protocol properties.

Properties of CAN Protocol as per Bosch CAN 2.0B specification

  1. Prioritization of messages
  2. Guarantee of latency times
  3. Configuration flexibility
  4. Multicast reception with time synchronization
  5. System wide data consistency
  6. Multi master
  7. Error Detection and signaling
  8. Automatic Retransmission of corrupted messages
  9. Acknowledgement and Sleep Modes.

Prioritization of messages

Via mailbox mechanism for both transmitting/receiving, the prioritization of messages is achieved. We can configure which messages has to be transmitted/received first based on the mailbox number or based on the message ID value that is binded with mailbox. Also, in terms of FIFO, we can configure in Message ID filter table, which Message IDs should be given priority based on the message ID value or based on order in which message ID are written in Filter table.

There is corresponding microcontroller CAN peripherally registers through which configuration of message prioritization can be done.

Configuration Flexibility

Configuration Flexibility we mean which transmitting and receiving messages. Using mailbox mechanism, we can configure any message ID to transmit CAN data and binding any message ID to mailbox number to receive CAN data via that message ID only.

Multimaster

The Node which is transmitting data is master and once that node has transmitted the CAN data, now any other node can send CAN data. Its nothing like that only one node can transmit data and has the control of CAN bus. Through the process of arbitration in CAN protocol, any node can transmit data and after it has transmitted successfully any new node can new data by taking control over the CAN Bus.

Multicast reception

The CAN Data which is send by one CAN node, can be received by number of CAN nodes only using 2 wires of CAN communication. No need of separate wire like CE in SPI or changing address in I2C. Using same 2 pins CAN_Tx and CAN_Rx, same message can be received by number of CAN nodes.

The receiving CAN node can configure its mailbox or FIFO filter table to receive the CAN data by the message ID which is transmitted by Transmitting CAN node. So now whenever in CAN Bus a CAN Data is transmitted by that message ID, it will be received by all CAN nodes.

For e.g their are 3 CAN Nodes. CAN Node A, CAN Node B and CAN Node C. Node A transmits CAN Data with message ID: 0x302. The data transmitted by Node A has to be received by Node B and Node C both. So, Node B can configure one of its mailboxes to get bind with 0x302 and Node C can configure in its message ID filter table 0x302.  So, both node B and Node C would be able to receive can data, without changing any address (like in case of I2C) or adding additional wire (like in case of SPI).

CAN Protocol Architecture

CAN protocol architecture has been divided into 2 layers according to OSI refrence Manual, so as to achieve design transperency and compatibility b/w any 2 CAN nodes:

  1. Physical Layer:
  2. Data Link Layer.

Physical Layer:  Defines electrical- mechanical characteristics and implementation for transfer of raw CAN data (bits and bytes) from one CAN node to another CAN node via wired physical medium. CAN transceiver comes in physical layer.

Data Link Layer: Defines CAN Hardware Controller characteristics for organizing the outgoing and incoming CAN data. So that CAN Protocol properties can be achieved. CAN peripheral or External CAN IC implements the Data link layer, as intructed above. Data link layer has to provide following things:

  1. Finding which messages are to be transmitted.
  2. Deciding which messages received are actually to be used.
  3. Providing an interface to the application layer to process CAN data communicated on physical layer.
  4. To provide means for recovery managment and overload notifications.
  5. Controlling the framing of CAN data for error-free transmission of data.
  6. Performing arbitration to decide which CAN node will transfer CAN data on CAN bus.
  7. Error Checking
  8. Message Filtering for received CAN data
  9. Message Transmission order while transmitting CAN data.

Conclusion

Now we will understand more about CAN protocol by Handson Practical’s. This blog must have given you brief and overview about practical implementation of CAN protocol. How CAN protocol should/can be used in different microcontrollers. Now if you read the datasheet on CAN peripheral, you will be able to understand that and process the terminologies, concepts, topics listed over their. Now further we are going to cover how to do CAN Communication on different Microcontrollers using knowledge imparted on this blog. 

We are at first going to start CAN Communication on NXP S32K1xx and NXP S32K3xx Microcontroller series via Autosar MCAL layer software stack. With time would be covering number of other Controllers too. But this blog would be used as starting point for all the practical implementation on CAN technology.

More Blogs to Read

Getting Started
Kunal Gupta

Getting Started with Autosar MCAL Layer

Overview So, hello guys, welcome to gettobyte platform. Continuing our Automotive technology series. In today’s blog we are going to start with Autosar technology of Automotive Industry. In the last blog, of automotive technology series we have get to know about Autosaur Technology. Now from this blog we will start with Handson activity and skill-based learning on Autosaur Technology using MCAL Layer. We will be mainly focusing on practical learning on Autosar, for theoretical understanding and concepts, will share necessary links and resources. What is Autosar Autosar is Software standard that has been standardized to write Software for automotive vehicles. Here by software, we mean by embedded software that is programmed in microcontrollers to develope automotive electronics/electrical sub-system. Autosaur has various layers in it, to know in detail about each of these layers and their role, explore/check out the last blog, or watch this video. To start with Autosar technology as a hobbyist and with DIY implementation, the easiest way is to start with the MCAL (Microcontroller Abstraction Layer) layer of Autosar technology. What is MCAL Layer? MCAL Layer is the closest layer to the microcontroller, and it is kind of like Real Time Driver (RTD) for all the peripherals of the Microcontroller in autosar software standard. Using this layer only, embedded software’s for automotive vehicles are developed. Those who don’t know, Real Time Driver (RTD) are software stack in microcontroller world to use microcontroller peripherals. For automotive application this Real Time Driver (RTD) Terminology is being referenced as MCAL(Microcontroller Abstraction Layer). To know more about software stacks used in microcontroller checkout this blog.To know about different kind of automotive embedded applications, checkout this blog.   Now what Autosaur technology has done is that whatever automotive embedded application we are developing, RTD (Real Time Driver) files that will be needing to develop application code would be same irrespective of microcontroller whether it is on NXP, Infineon, Renesas or etc. So, each microcontroller company has to make the Real Time Driver for their Microcontroller up to the MCAL layer standard so that their microcontrollers can be used for automotive applications. To know about microcontroller, checkout this blog. So it also means, that doing handson with MCAL layer for any one microcontroller, it will give us basic/intermediate level of learning, understanding and knowledge to build different applications according to autosar software standard. And this is what we are going to follow.  Strategy to learn autosar technology Autosar technology is a very important skill for job seekers in the automotive industry. Be it a working professional, college student or fresh graduates, having the skill set of autosar technology in their resume makes them outstand.  But there are certain challenges in learning autosar technology. For learning autosar technology an automotive microcontroller is required so that we can make DIY and practical automotive projects using autosar software stack. Thus, what we are going to follow is we will learn and do Hands-on with MCAL layer of automotive Microcontrollers, for building automotive applications and the MCAL layer stack is provided by respective microcontroller companies. As Only for automotive microcontroller’s MCAL layer is available. MCAL layer is not available for General Purpose microcontroller like that of: STM32, ESP8266/32 and Arduino Uno boards. So, to use MCAL layer first requirement is to have a microcontroller and its development readily available. Here come’s the ElecronicsV2 development board. ElecronicsV3 board, which is development board for developing automotive applications/projects using autosar software stack It is low-cost Automotive, development board based on S32K144 automotive Microcontroller. Comes at cost of 5000 INR. In autosar technology as told there are many layers, as told in what is autosar section. So, to use and configure layers above MCAL layer, there are specific code configuration tools and IDEs for using autosar Stack. These tools are provided by companies like: Electrobit, Mentor Graphics, Vector and etc. But these tools are very expensive. Thus, what we are going to do is we will start from MCAL layer, as MCAL layer code configuration, generation and development can be done by IDE which are provided by microcontroller companies. Thus, for elecronicsV2 development board which has NXP semiconductors S32K144 Microcontroller there is S32 Design Studio IDE in which we can do full MCAL layer configuration, generation and development. Using MCAL layer we will develop different application by interfacing different automotive sensor/modules to ElecronicsV2. By this way we will be able to make automotive applications using MCAL layer that will give us exposure to autosar software architecture Tools Needed Hardware We will be doing this activity using NXP Semiconductor S32 Microcontroller family. NXP S32 family of Microcontroller, are automotive grade MCU’s for which NXP provides full MCAL layer support for all of its S32 MCU’s. To know more about NXP S32 Family of Automotive Microcontroller/Microprocessor, checkout this blog. One such microcontroller of NXP is S32K144, for which gettobyte has developed a cost friendly and easy to use development Board ElecrronicsV2. We will be using this Development Board (ElecronicsV2) and Microcontroller(S32K144) through-out our Autosaur learning series. To know more about elecronicsV2 board and S32K144 Microcontroller, checkout this blog. And for programming and debugging the ElecronicsV2 board, we will be needing a debugger. JlinkV9 debugger is what we are going to use initially, but soon in upcoming time, gettobyte will be coming up with its own Jlink debugger. That will be updated soon. To know more about Debuggers in microcontroller world, checkout this blog: Mastering the Art of Debugging Technology in Microcontrollers So before continuing further will recommend buying the elecronicsV2 board and JlinkV9 debugger from below links: 1) ElecronicsV2: Arduino of automotive world. 2) JlinkV9 Debugger: Universal Debugger for all ARM Based MCU’s. Software In terms of Software, we will be needing an IDE (Integrated Development Environment) to develop embedded software on microcontroller. For that we will be using S32 Design Studio, which is dedicated IDE for NXP S32 Automotive Microcontroller’s. For the Installation of S32 Design Studio and guide on it, refer to following playlist on my YouTube Channel: NXP Semiconductors S32 Design Studio – YouTube.

Read More »
Cryptography
Kunal Gupta

Cryptography Do It Yourself (DIY) projects

Table of Contents   Overview https://gettobyte.com/wp-content/uploads/2023/12/20240211232811.mp4 So, hello guys, welcome back to the gettobyte YouTube channel. The video you have just seen is the encryption-decryption of an image using Microcontrollers. And that’s what we will implement and learn to do in today’s video. We are going to explore, how to use cryptography technology in microcontrollers. Will be doing the hands-on activity for encryption/decryption of data and images using the ElecronicsV2 Development board. Encryption/Decryption is the cryptography concept and what we are going to achieve on doing so is to know how to use cryptography technology through microcontrollers. For doing Encryption/decryption we are using the AES cryptography algorithm, which is supported in the ElecronicsV2 development board through its SHE standard-based CSEc peripheral. For those who are new to the channel and world of cryptography technology, would recommend watching these videos in the following hierarchical order to get an understanding of cryptography and the technical terms that have been stated just now. What is Cryptography How Cryptography is implemented in Microcontrollers Cryptography basic understanding and terminologies DIY Project Statement What i have done here is take an image, which is an original image and convert it into a string of bytes. After that, wrote software to store that string of bytes in the ElecronicsV2 development board and to do encryption through AES cryptography algorithm on the stored data. On successful encryption, those string of bytes are changed to the encrypted format of data and then that encrypted data is processed to print the encrypted image on color LCD Screen. This is just a basic demo on how to use cryptography technology for securing the original data. Here we are printing encrypted image on the LCD Screen, Same way we can send, encrypted image data to other microcontroller via CAN, LIN or any other protocol. Will be doing this activity too in upcoming blogs. Follow this cryptography technology playlist to explore more such demos. Tools needed Now to achieve this, we will be needing some Hardware and Software tools. In Hardware part, we will be needing: 1) ElecronicsV2 Development Board: BuyLink 2) JlinkV9 Debugger: Debugger to program the ElecronicsV2 Board: Buy Link 3) Double Breadboard: 4) ST7789 Color LCD Screen: LCD screen for printing images ElecronicsV2 Development Board JlinkV9 Debugger Double Breadboard ST7789 Color LCD Screen ElecronicsV2 Development Board ElecronicsV2 is a development board built on NXP Semiconductors S32K144 Microcontroller. S32K144 MCU is an automotive Microcontroller based on ARM Cortex M4 Processor and is part of NXP S32 Automotive Microcontroller family. ElecronicsV2 board which is built on S32K144 MCU has a cryptography peripheral present in it, called as CSEc(Cryptography Security Engine). Which is a SHE standard based security sub-system for doing cryptographic operations and establishing secure communication b/w the ECU and the sensors/actuators of the car. We are gonna use CSEc peripheral of S32K144, to do encryption/decryption of data JlinkV9 Debugger JlinkV9 Debugger is a hardware debugging tool, that is used to program and debug ARM cortex-based Microcontroller or Microprocessor.  You can buy the JlikV9 from this link. ElecronicsV2 has to be connected to Jlink V9 debugger, so that we can program/debug the board. To know about its connection Double Breadboard Tab Content ST7789 Color LCD Screen ST7789 Color LCD Screen In software we will be needing 1) S32 Design Studio IDE: Which is a Desktop Application for programming S32 Family of microcontroller’s/microprocessor. 2) LCD image converter: Desktop application to convert the image into string of bytes S32 Design Studio IDE LCD image converter S32 Design Studio IDE S32 Design Studio is the IDE that is used for development of Embedded Software Development on S32 family of Microcontrollers. IDE stands for Integrated Development Environment, which is used for doing software development on microcontrollers. ElecronicsV2 board has S32K144 Microcontroller, which is part of NXP Semiconductor S32 family of MCU. Thus, we will be using S32 Design Studio for doing Handson activity with ElecronicsV2 boards, S32 Design Studio: is an Integrated Development Environment to write the microcontroller programs for S32 Automotive Microcontrollers. Install the S32 Design Studio software in your PC and in addition to it user also have to download the Real Time Driver (RTD) package for S32K1 MCU. Refer to this blog for full installation guide of S32 Design Studio step-by-step: Getting Started with S32 Design Studio Part 1 | Gettobyte LCD image converter We will use this software to convert the images into string of bytes. How to use this software is mentioned below: Getting Started Okay so now let’s get started with it, i hope so you guys have gathered all the software/hardware that i have mentioned above and connected all the hardware items. We will at first directly gonna do the practical implementation and then going to dwell deep into it. Now for microcontroller programming on ElecronicsV2, I am making a separate GitHub repo, where all the demo examples and peripherals codes would be committed with time. Clone the repo, into your local PC. Link of the repo: Now in the repo, navigate to: Peripheral Drivers-> CSEc , here you will see different examples related to cryptography technology in ElecronicsV2 Development board.  The CSEc_AES_ENC_CBC_ECB_ST7789, is the project for which demo video is shown to you in the starting of the blog. We are going to execute and understand this project. After cloning the project into your PC, you can see the same folder structure as shown to you at GitHub repo at the path Peripheral_Drivers->CSEc: Now open the S32 Design Studio and we have to open the Project CSEc_AES_ENC_CBC_ECB_ST7789 into it.  CSEc_AES_ENC_CBC_ECB_ST7789 is already developed code, so to open it navigate to file->Open Project from File System To know how to open already developed project in S32 Design Studio, refer to this blog: Getting Started with S32 Design Studio Part 1 | Gettobyte. After opening the project, you can see it open in project explorer window of S32 Design Studio. Opening the Cryptography example projects Opening the Cryptography example projects in S32 Design Studio. In this example project you will find

Read More »

Embedded Hardware kits

Evalution Kits

SmartwheelsV1 Programmable ECU for Automotive STM32_Energy_Metering Energy Metering Evalution Kit Open ECU(STM32F103) Cost Effective board for Automotive

Read More »

Development Boards

ElecronicsV2(S32K144) Arduino of Automotive World Obseleted ElecronicsV3(S32K144) Arduino of Automotive World On-Board Jlink Debugger IMU+CAN OnBoard VehronicsV1(S32K148) Arduino Mega of Automotive World JN5189 Module Zigbee, Thread and NFC IoT Module

Read More »
Kunal Gupta

AutoBoardV1 Development Board

What is AutoboardV1 Short Intro on AutoBoardV1 AutobordV1 is System on Module (SoM) based on NXP Semiconductors Automotive Microcontroller S32K344. Based on ARM Cortex M7 processor-based Microcontroller S32K344, AutoboardV1 is compact and cost-effective SoM specifically for automotive applications.  AutoboardV1 can be used for prototyping/development/research/corporate trainings/academia for building Automotive technologies/applications like: ADAS subsystems, Domain/Zonal Control architecture and ECU gateway in vehicles.  Explore Usecases section to know solutions that can be built using AutoboardV1. Also, AutoboardV1 has Full HSM (Hardware Security Module) based automotive controller, automotive peripherals like: CAN, LIN, Ethernet, FlexIO, QuadSPI, Advance Timers and ADC making it ideal for building secure, smart, powertrain and body control domain automotive electronic devices like Electric Immobilizer, Domain Controller, IoT gateway for automotive and etc. Explore DIY projects section to know more about such devices that can be built using AutoboardV1 Additional to that AutoboardV1 also supports full Embedded Toolchain of Matlab/Freemaster/S32 Design Studio and Autosaur MCAL layer to start your development and application building straight out of the Gettobyte Software Material and Content. Buy Now Previous slide Next slide Previous slide Next slide Autosar MCAL Layer Support EVITA Full HSM Based Crypto Engine: HSE OpenSDA based Onboard Debugger Functional Safety ISO26262 complaint upto ASIL D MATLAB Simulink and NXP MBDT tools Freemaster Debugging Tool Automotive Ethernet MII Interface // Kew Features Technical Hardware Features of AutoboardV1 S32K344 MCU in MFQP174 pin package AutoboardV1 is built on NXP Semiconductors Automotive Microcontroller S32K344, which supports Security and Ethernet Features Adaptor based Power Supply 6-17V adaptor for power supply 80 pins I/O Headers 80 pins I/O header pins exposing majority of pins for external use and also in breadboard compatible size 24 pins I/O Headers 24 pins I/O header pins exposing rest of pins for external use via jumper wires or shields 2 OnBoard User Buttons On Board Tactile User buttons via GPIO peripheral Onboard 3 CAN2.0B Ports via screw terminals AutoboardV1 has 3 CAN ports, with one CAN wakeup switch: 1xCAN 2.0B using TJA1443 and 2x CAN 2.0B using TJA1051 On Board 1 automotive ethernet using screw terminals On board 1 automotive ethernet using TJA1101 DUAL LIN Ports via screw terminals On Board 2 lin ports using TJA1022 64 Mbit Automotive QUADSPI Flash Onboard MX25L6433FM2I QUADSPI Memory Chip OnBoard Crystal Oscillator 16Mhz On Board Crystal Oscillator On Board OpenSDA based Debugger via Type C port OpenSDA based Debugger to program and debug the S32K344 via onboard debugger. Onboard SWD 10-pin Connector for SWD Debugging SWD debugging via external Jlink Debuggers or PE Micro Debuggers On Board UART Port via USB type C On Board UART Port using CP2102 for runtime logs and debugging Analog Power Configuration ADC reference voltage configuration between 3.3V and 5V 2 OnBoard RGB LED On Board RGB LED via GPIO and PWM peripheral Applications Usecases of AutoboardV1 Build ECU Gateway controllers for Domain/Zonal Architecture.Click HereEnable/Learn Cryptography Technology to in embedded world to make smart and secure automotive applications using Full Hardware Security Module: HSE peripheral present in S32K344 MCUClick HereLearn/Explore Autosar MCAL Layer with AutoBoardV1Click HereLearn automotive protocols with AutoBoardV1Click HereAutomotive Industrial Solutions using AUtoboardV1 ( Matlab and FreeMAster)Automotive DIY projects for academia to start with using AutoboardV1Click HereBuild Powertrain, Electrification, Motor control and Body control Specific automotive applications via AutoboardV1Click Here Previous slide Next slide Pricing & Buy Start With An Affordable AutoboardV1 S32K344 Automotive System on Module Buy Now Popular AutoboardV1 INR17K/piece Domestic Shipping Readily available Autosar MCAL Layer Support Automotive MCU S32K344 Ethernet, CAN, LIN on-board On-Board Jlink Support Contact Us Click here Pinout AutoboardV1 Pinout ElecronicsV2 Pinout Target Audience Perfect Embedded Hardware Board for Freshers and working professionals. Skill Sets Learn Embedded Basics Learn Basics of Microcontroller world using Industrial tools and framework like: Eclipse Based IDE, Jlink Debuggers, Microcontroller Software Packages (RTD, HAL) and Datasheet. Skill Sets Learn Autosar Stack Wanna learn and build skill sets for Autosaur Technology. ElecronicsV2 has support of Autosaur MCAL layer integrated with eclipse-based IDE.. Skill Sets Learn Device Driver Development Learn how to use Microcontroller Peripherals like: GPIO, UART, I2C, SPI, Timers, Interrupts, DMA and etc with industrial Microcontroller Software Packages and stacks. Skill Sets Learn FreeRTOS Learn FreeRTOS using automotive Skill Sets Learn Automotive Peripherals Learn automotive peripherals like: CAN, LIN, FlexTimers, Hardware Security Modules on Industrial Microcontroller in cost effective ways. Project Building Build Automotive projects. Build Automotive projects in DIY form using Automotive sensors and frameworks. Perfect Embedded Hardware Kit for Automotive Startups/Corporates Proof Of Concept Build automotive Proof of Conecpt Nanotechnology immersion along the information highway will close the loop on focusing solely Research Prototype/Reasearch based on Automotive cjips Nanotechnology immersion along the information highway will close the loop on focusing solely Easy to Use Plug and Play system Nanotechnology immersion along the information highway will close the loop on focusing solely // Embedded Tools and Frameworks To use AutoboardV1 NXP Semiconductors provide Embedded Software tools and gettobyte provides Embedded Hardware Tools to start your journey on S32K3 series of Microcontroller. From Integrated Development Environment (IDE) to Microcontroller Software packages for S32K3xx series of Microcontroller. As ElecronicsV2 is built on S32K344 Microcontroller, which belongs to S32K3xx series. So toolchains will be same for using AutoboardV1 boards. S32 Design studio IDE to write programs for AutoboardV1 ProBug Debugger Debuggers to flash the programs into AutoboardV1 boards. S32 Autosar RTD Autosaur 4.4 version based Software stack (MCAL Layer) for using S32K344 Peripherals // Resources, Tutorial Content and Courses To use AutoboardV1   Getting Started with AutoboardV1   Peripheral Drivers for AutoboardV1   DIY Project with AutoboardV1   Sensor and Module Interfacing with AutoboardV1 // User Manual and User Guide To use AutoBoardV1 User Manual of NXP S32K344 MCU based System on Module: AutoBoardV1. Getting Started Manual of NXP S32K344 MCU based System on Module: AutoBoardV1

Read More »

SmartWheelsV1 Development Board

What is SmartwheelsV1 Short Intro on SmartWheelsV1 SmartWheelsV1 is a Programmable ECU(Electric Control Unit), which can be used for prototyping/development of automotive products and training to upskill knowledge in the automotive sector, which is one of the first of its kind in the automotive sector as Programmable ECU. It is built on Automotive microcontroller which has software support of Autosar MCAL layer support and MATLAB Simulink, making it ideal for building automotive powertrain and body control concentric applications like: Instrument Cluster, Domain, Battery swapping technologies, Engine control units. Buy Now Previous slide Next slide Autosar MCAL Layer Support SHE Standard Based Crypto Engine MATLAB Simulink with MBDT tools Functional Safety ISO26262 complaint upto ASIL B Freemaster Debugging Tool FreeRTOS and Non Autosar based RTD // Kew Features Technical Hardware Features of SmartWheelsV1 S32K144 MCU in LFQP100 pin package ElecronicsV2 is built on NXP Semiconductors Automotive Microcontroller S32K144. On-Board UART for debugging via Type C USB cable Turn to our experts to perform comprehensive, multi-stage testing and auditing of your software. Reset and Power Conffiguration Trust our top minds to eliminate workflow pain points, implement new tech, and consolidate app. Onboard RGB LED and 2 switches Create complex enterprise software, ensure reliable software integration, modernise your legacy system. On-Board CAN transceiver IC TJA1051 via green screw Terminals Trust our top minds to eliminate workflow pain points, implement new tech, and consolidate app. Detail Silk Screen Trust our top minds to eliminate workflow pain points, implement new tech, and consolidate app. 1 Variable Potentiometer Build the product you need on time with an experienced team that uses a clear and effective design. Onboard JTAG-SWD 10-pin Connector for JLink SWD Debugging Over the past decade, our customers succeeded by leveraging Intellectsoft’s process of building, motivating. Plug and Play for Development Trust our top minds to eliminate workflow pain points, implement new tech, and consolidate app. Pricing & Buy Start With An Affordable Engitech is the partner of choice for many of the world’s leading enterprises, SMEs and technology challengers. We help businesses elevate their value through custom software development Buy Now Popular ElecronicsV2 Contact Us Domestic Shipping Readily available Cost Effective and easy to use Pinout ElecronicsV2 Pinout ElecronicsV2 Pinout Previous slide Next slide Applications Usecases of ElecronicsV2 Build Powertrain and Body control Specfic automotive applicationsClick HereEnable/Learn Cryptography Technology to in embedded world to make smart and secure automotive applicationsClick HereBuild Small ECU nodes for Domain/Zonal Architecture.Click HereLearn/Explore Autosar MCAL Layer with ElecronicsV2Click HereLearn Automotive Peripherals with ElecronicsV2Click HereHow to transition from Arduino/ESP to Industrial Microcontroller( S32K144 MCU)How to start Embedded Software Development?Click Here Previous slide Next slide Target Audience Perfect Embedded Hardware Board for Freshers and working professionals. Skill Sets Learn Embedded Basics Learn Basics of Microcontroller world using Industrial tools and framework like: Eclipse Based IDE, Jlink Debuggers, Microcontroller Software Packages (RTD, HAL) and Datasheet. Skill Sets Learn Autosar Stack Wanna learn and build skill sets for Autosaur Technology. ElecronicsV2 has support of Autosaur MCAL layer integrated with eclipse-based IDE.. Skill Sets Learn Device Driver Development Learn how to use Microcontroller Peripherals like: GPIO, UART, I2C, SPI, Timers, Interrupts, DMA and etc with industrial Microcontroller Software Packages and stacks. Skill Sets Learn FreeRTOS Learn FreeRTOS using automotive Skill Sets Learn Automotive Peripherals Learn automotive peripherals like: CAN, LIN, FlexTimers, Hardware Security Modules on Industrial Microcontroller in cost effective ways. Project Building Build Automotive projects. Build Automotive projects in DIY form using Automotive sensors and frameworks. Perfect Embedded Hardware Kit for Automotive Startups/Corporates Proof Of Concept Build automotive Proof of Conecpt Nanotechnology immersion along the information highway will close the loop on focusing solely Research Prototype/Reasearch based on Automotive cjips Nanotechnology immersion along the information highway will close the loop on focusing solely Easy to Use Plug and Play system Nanotechnology immersion along the information highway will close the loop on focusing solely // Embedded Tools and Frameworks To use ElecronicsV2 NXP Semiconductors provide Embedded Software tools and gettobyte provides Embedded Hardware Tools to start your journey on S32K1 series of Microcontroller. From Integrated Development Environment (IDE) to Microcontroller Software packages for S32K1xx series of Microcontroller. As ElecronicsV2 is built on S32K144 Microcontroller, which belongs to S32K1xx series. So toolchains will be same for using ElecronicsV2 boards. S32 Design studio IDE to write programs for ElecronicsV2 Jlink Debuggers Debuggers to flash the programs into ElecronicsV2 boards. S32 Non Autosar SDK Non-Autosaur based Software stack of peripheral drivers, RTOS and middleware for using S32K144 S32 Autosar RTD Autosaur 4.4 version based Software stack (MCAL Layer) for using S32K144 Peripherals // Resources, Tutorial Content and Courses To use ElecronicsV2 Getting Started with ElecronicsV2 Peripheral Drivers for ElecronicsV2 DIY Project with ElecronicsV2 Sensor and Module Interfacing with ElecronicsV2

Read More »

ElecronivsV2 Development Board

What is ElecronicsV2 Short Intro on ElecronicsV2 ElecronicsV2 is a versatile development board based on the NXP Semiconductor S32K144 MCU, designed for automotive enthusiasts and tech hobbyists. This board is equipped with a rich set of onboard features and interfaces for various Automotive DIY projects. In an era, where the automotive sector is at its prime and everyone desires to make theircareer advancements in the Automotive field, there is a need for a Microcontroller baseddevelopment board that is of automotive grade, with automotive capabilities to do directlearning and gain knowledge on automotive/Embedded skill sets by making Industrial DIY projects And in such a world, ElecronicsV2boards make a grand entrance. Buy Now ElecronicsV2 is obseleted now, users interested can refer ElecronicsV3 which has onBoard Jlink Debugger and IMU sensors for hassle-free enablement on automotive learning and projects. Autosar MCAL Layer Support SHE Standard Based Crypto Engine MATLAB Simulink with MBDT tools Functional Safety ISO26262 complaint upto ASIL B Freemaster Debugging Tool FreeRTOS and Non Autosar based RTD // Kew Features Technical Hardware Features of ElecronicsV2 S32K144 MCU in LFQP100 pin package ElecronicsV2 is built on NXP Semiconductors Automotive Microcontroller S32K144. On-Board UART for debugging via Type C USB cable CP2102 Based USB to UART converter at LPUART1 port for logging runtime values and also for powering the board via Type C cable Reset and Power Conffiguration Slider for: Power Configuratio via UART Type C cable or Debugger Connector and Reset Configuration via Onboard reset button or Jlink Debugger Onboard RGB LED and 2 switches RGB LED at PD15, PD16 and PD0 along with 2 tactile switches at PC12 and PC13 On-Board CAN transceiver IC TJA1051 via green screw Terminals CAN2.0B complaint at CAN0 using PE5 and PE4 as CAN Tx-Rx pins, with CAN terminal Enable header Detail Silk Screen No Need to refer docs again and again, all Pins information and Labelling on the board. 1 Variable Potentiometer Potentiometer at PC14 for playing ADC of S32K144 MCU Onboard JTAG-SWD 10-pin Debugger Connector OnBoard 10 pin SWD connector for debigging and programming via external debugger like Jlink or PEMicro Plug and Play for Development Breadboard Compatible Design, which exposes all of the pins of the Microcontroller and easily cpnnects external sensor/module’s. Pricing & Buy Start With An Affordable ElecronicsV2 is easy to use Buy Now Popular ElecronicsV2 INR5.5K/piece Automotive Microcontroller Board Readily available Cost Effective and easy to use >>INR 12K/piece Hobbyist- Tech Enthusiasts -Students Premium ElecronicsV2 with Automotive Autosar MCAL layer Course INR10K/piece Automotive Microcontroller Board with Autosar Handson course Autosar MCAL layer understanding Use of MCU peripherals via MCAL layer RTD Skill Development and Learning Pinout ElecronicsV2 Pinout ElecronicsV2 Pinout Previous slide Next slide Applications Usecases of ElecronicsV2 Build Powertrain and Body control Specfic automotive applicationsClick HereEnable/Learn Cryptography Technology to in embedded world to make smart and secure automotive applicationsClick HereBuild Small ECU nodes for Domain/Zonal Architecture.Click HereLearn/Explore Autosar MCAL Layer with ElecronicsV2Click HereLearn Automotive Peripherals with ElecronicsV2Click HereHow to transition from Arduino/ESP to Industrial Microcontroller( S32K144 MCU)How to start Embedded Software Development?Click Here Previous slide Next slide Target Audience Perfect Embedded Hardware Board for Freshers and working professionals. Skill Sets Learn Embedded Basics Learn Basics of Microcontroller world using Industrial tools and framework like: Eclipse Based IDE, Jlink Debuggers, Microcontroller Software Packages (RTD, HAL) and Datasheet. Skill Sets Learn Autosar Stack Wanna learn and build skill sets for Autosaur Technology. ElecronicsV2 has support of Autosaur MCAL layer integrated with eclipse-based IDE.. Skill Sets Learn Device Driver Development Learn how to use Microcontroller Peripherals like: GPIO, UART, I2C, SPI, Timers, Interrupts, DMA and etc with industrial Microcontroller Software Packages and stacks. Skill Sets Learn FreeRTOS Learn RTOS using ElecronicsV2,: FreeRTOS Skill Sets Learn Automotive Peripherals Learn automotive peripherals like: CAN, LIN, FlexTimers, Hardware Security Modules on Industrial Microcontroller in cost effective ways. Project Building Build Automotive projects. Build Automotive projects in DIY form using Automotive sensors and frameworks. Perfect Embedded Hardware Kit for Automotive Startups/Corporates Proof Of Concept Build automotive Proof of Conecpt Struggling to find right kind of Embedded Hardware kits to build the proof of concept of your automotive products. Our Embedded Hardware Kits Would be helping partner for that. Research Prototype/Reasearch based on Automotive chips Building Automotive products require use of Semiconductor chips like that of NXP, Renesas, TI or Infineon. Explore Our Embedded Hardware kits which are based on Such Microcontroller Chips Easy to Use Plug and Play system Building/Developing Automotive Products, often require use of Hardware Kits which are easy to use and can be easily programmed with custom application, in addition to that based on Industrial Microcontrollers. Our Embedded Hardware Kits is solution to all listed needs. // Embedded Tools and Frameworks To use ElecronicsV2 NXP Semiconductors provide Embedded Software tools and gettobyte provides Embedded Hardware Tools to start your journey on S32K1 series of Microcontroller. From Integrated Development Environment (IDE) to Microcontroller Software packages for S32K1xx series of Microcontroller. As ElecronicsV2 is built on S32K144 Microcontroller, which belongs to S32K1xx series. So toolchains will be same for using ElecronicsV2 boards. S32 Design studio IDE to write programs for ElecronicsV2 Jlink Debuggers Debuggers to flash the programs into ElecronicsV2 boards. S32 Non Autosar SDK Non-Autosaur based Software stack of peripheral drivers, RTOS and middleware for using S32K144 S32 Autosar RTD Autosaur 4.4 version based Software stack (MCAL Layer) for using S32K144 Peripherals // Resources, Tutorial Content and Courses To use ElecronicsV2 Getting Started with ElecronicsV2 Peripheral Drivers for ElecronicsV2 DIY Project with ElecronicsV2 Sensor and Module Interfacing with ElecronicsV2 // User Manual and User Guide To use ElecronicsV2 User Manual of ElecronicsV2 User Guide of ElecronicsV2 // our other Embedded Hardware Kits Read About Our latest Kits All News // our clients Our Reach across India Ancit Technologies Automotive Consulting Company “Very well thought out and articulate communication. Clear milestones, deadlines and fast work. Patience. Infinite patience. No shortcuts. Even if the client is being careless. The best part…always solving problems with great original ideas!.” Skill Lync E-Learning Providers “Patience. Infinite patience. No

Read More »
Kunal Gupta
Author: Kunal Gupta

Author

Kunal Gupta

Leave a comment

Stay Updated With Us

Error: Contact form not found.

      Blog