- Setting up CANlib in Visual Studio
- Basic API Calls
- Event Driven Applications
- EETimes Automotive
- l'Embarque
- New Electronics
- Electronics Specifier
- Evertiq EU & Swedish version
- Electronik Tidningen
- Electronics Weekly and
- CiA Newsletter, among others.
- Kvaser Leaf Professional HS (EAN: 73-30130-00243-2)
- Kvaser Leaf Professional HS OBDII (EAN: 73-30130-00404-7)
- Kvaser USBcan Professional HS/HS (EAN: 73-30130-00357-6)
Intro
In our last video we showed how to create a console application that could configure and read messages from the CAN bus using basic API calls available in our CANlib SDK. In this video, we will focus on how to make your read loop event driven to be more efficient.Example
In the previous examples we used a Windows C# console application. Since we want to show the event driven loop in a multiple thread application, this example will use a Windows Presentation Foundation program where the main thread handles the graphic user interface (GUI) and a background thread reads the data from the CAN bus. We have a simple graphic user interface with one button to start the background thread and one button to stop the background thread. We've also added a text box to display the received messages. We've designed this GUI using XAML. We will use a .NET Background Worker thread to perform all of the CAN bus manipulation. This means that we must include the System ComponentModel namespace and create the background worker when the main window is created. All that is left for the GUI to do is to start the background worker when the Bus On button is pressed, stop the background worker when the Bus Off button is pressed, and display the string reported from the background thread. Our background worker will execute the ReceiveMessageLoop function to retrieve data from the CAN bus. Like in our previous examples, we need to include canlibCLSNET namespace and setup a handle to the Kvaser device. We have placed the handle setup calls in the InitializeChannel function. We initialize the library, get a handle, set the bit rate and make the channel active on the bus. We have also added a call to canIoCtl to get a Windows event handle that will trigger when something happens in the driver.That something could be a CAN bus message received, message transmitted, or a change in the CAN controller state. Regardless of why the event triggered, you must empty the receive buffer or you will not get another event trigger. You will notice that the pointer returned by canIoCtl must be placed inside a Class derived from the WaitHandle class. To use the WaitHandle class we must include the System.Threading namespace. We now have a properly initialized channel handle and an event handle, so back in the ReceiveMessageLoop we loop until the GUI requests the background worker to stop. Inside the loop we wait up to 1 second for an event to occur using the WaitAny method. If no event occurs, we loop again. If the CAN event does trigger, we loop reading messages with the canRead call until the function indicates the receive buffer is empty with a canERR_NOMSG status. For each message processed, we pass the message information back to the GUI with the ReportProgress method built into the BackgroundWorker class. If the GUI requests the background worker to stop, we fall out of the while loop to the ReleaseChannel function which handles our standard cleanup by making the channel inactive and closing the handle. Now the application is still responsive while using less CPU resources since we are only checking for messages and updating the display when a CAN event or user event occurs. Keep in mind when using multiple threads, that the handle returned by the canOpenChannel call is not thread safe. So each thread must claim their own handle to the physical channel with the canOpenChannel function.More Info
For more information about CANlib, you can view our CANlib SDK Help and check out our series of developer blogs.
[/vc_column_text][/vc_column][/vc_row] [post_title] => Setting up CANlib: Event Driven [post_excerpt] => [post_status] => publish [comment_status] => closed [ping_status] => closed [post_password] => [post_name] => setting-up-canlib-event-driven [to_ping] => [pinged] => [post_modified] => 2022-10-04 13:14:38 [post_modified_gmt] => 2022-10-04 13:14:38 [post_content_filtered] => [post_parent] => 0 [guid] => https://www.kvaser.com/?post_type=developer_blog&p=39868 [menu_order] => 0 [post_type] => developer_blog [post_mime_type] => [comment_count] => 0 [filter] => raw ) [3] => WP_Post Object ( [ID] => 39869 [post_author] => 14 [post_date] => 2015-09-22 13:15:31 [post_date_gmt] => 2015-09-22 13:15:31 [post_content] => [vc_row][vc_column width="1/1"][vc_video link="https://www.youtube.com/watch?v=WgFXqpCKE8M"][vc_column_text]This is the second post in a 3-part series about CANlib development:- Setting up CANlib in Visual Studio
- Basic API Calls
- Event Driven Applications
Intro
In the last video, we established how to add the CANlib SDK resources to your own Visual Studio project. In this video we will walk through the minimum CANlib function calls for configuring and reading messages from the CAN bus through a Kvaser unit. We have already added the necessary code to the example project from our last video. This code will configure the unit or a virtual channel for 250 kbps and then loop, reading every CAN frame on the bus until the user presses the escape button.Example
To accomplish this, the first step as we described in the previous video, is to import the canlibCLSNET types with the "using" directive. Our first CANlib function call must be canInitalizeLibrary. Calling this function causes the necessary DLLs to be loaded into memory and all connected Kvaser hardware is assigned a channel number. We now need to get a handle to a Kvaser CAN circuit using the canOpenChannel function. The handle returned is necessary for subsequent calls to the library. The first parameter specifies the desired CAN circuit. The second parameter allows for additional qualifying flags. In this case, we are accepting handles to virtual channels. Now that we have a handle, we can configure the circuit to the appropriate bitrate for the CAN bus that we're connecting to. The canSetBusParams function supports setting each of the bus parameter values or using one of Kvaser's predefined bitrates. We are using the predefined bitrate of 250 kbps. Once you have configured the bitrate, you can make the circuit active on the CAN bus by calling canBusOn. Once this function has executed, the CAN circuit is actively participating in CAN traffic. You may have noticed that we call DisplayError after each call to a CANlib function. For cleaner code, we are processing the error status returned from CANlib in a separate function. If there is an error condition, we translate the error code to a string description using the canGetErrorText function. Checking the status returned by CANlib functions is essential to understanding where problems are occurring. Back in Main, we have finished configuring and activating the circuit, so we can loop reading the CAN frames from the bus. We will use canReadWait to retrieve the CAN frames. A CAN frame consists of an identifier (id), 0 to 8 data bytes (data), a data length code (dlc), message attributes (flags), and a time stamp (time). The final parameter in canReadWait specifies how long to wait in milliseconds for a CAN frame if the receive buffer is empty. So, when the canReadWait returns we need to check a couple of things before assuming we have a message. If the returned status value is canOK, we know we have something to process. If the returned status is canERR_NOMSG, then we simply need to loop again. But if the returned status is any other value, the handle to the circuit can no longer be used for reading CAN data. Again, to make the code easier to read we have placed the data processing code in a separate function called DisplayMessage which is executed when canReadWait returns a status of canOK. DisplayMessage shows many pieces of information that can be extracted from the CAN frame data returned. But most importantly, the function checks the second indicator of whether an actual CAN data frame was received. This is done by checking for the canMSG_ERROR_FRAME bit in the flags parameter. If the bit is set, you received an error frame and you do not process the identifier, data length code, or data parameters. If the bit is not set, you have received a CAN data frame and should process the frame as desired. Once you are finished, you should gracefully close your program by making the CAN circuit inactive on the bus using the canBusOff function and then freeing the handle with the canClose function. Now let's run our new console application and see it work in real time. As you can see, the app was able to connect to a device, begin receiving can frames, and process them until we pressed Escape to exit.More Info
For more information about CANlib, you can view our CANlib SDK Help and check out our series of developer blogs.
[/vc_column_text][/vc_column][/vc_row] [post_title] => Setting Up CANlib: Basic API Calls [post_excerpt] => [post_status] => publish [comment_status] => closed [ping_status] => closed [post_password] => [post_name] => setting-up-canlib-basic-api-calls [to_ping] => [pinged] => [post_modified] => 2022-10-04 13:17:41 [post_modified_gmt] => 2022-10-04 13:17:41 [post_content_filtered] => [post_parent] => 0 [guid] => https://www.kvaser.com/?post_type=developer_blog&p=39869 [menu_order] => 0 [post_type] => developer_blog [post_mime_type] => [comment_count] => 0 [filter] => raw ) [4] => WP_Post Object ( [ID] => 39870 [post_author] => 14 [post_date] => 2015-09-15 13:20:57 [post_date_gmt] => 2015-09-15 13:20:57 [post_content] => [vc_row][vc_column][vc_column_text]This is the last post in a 3-part series about Environment Variables in t programs:- Introduction to Environment Variables
- Accessing Environment Variables from CANlib
- Kvaser TRX and Environment Variables
envvar.t. We do this by selecting File->Open, then browse for the file, select the file, and click "Open".[/vc_column_text][vc_single_image image="8109" img_size="full"][vc_column_text]Figure 1: Kvaser TRX is started, we have an Eagle connected to the PC and the file envvar.t is loaded.[/vc_column_text][vc_column_text]The next step is to Compile, Download and Run the t program. A quick way of doing this is to push the play button on the Kvaser TRX toolbar. A pop-up will ask you to save your new project. Just accept the default name and click "Save".
The t program will now start, indicated by the message "Script no 0 started. proc=0" in the Device Output part of the lower pane. After the simulated boot delay, a new message will appear, "Signal that we are ready to accept connections", see Figure 2.[/vc_column_text][vc_single_image image="8116" img_size="full"][vc_column_text]Figure 2: The t program has been started and we can see print outs in the Device Output tab of Kvaser TRX.[/vc_column_text][vc_column_text]To view an environment variable, we first open up the Envvar window by selecting Window->Toggle Envvar Window from the menu. In the Envvar Window we enter the name of the environment variable we would like to view, and click "Add Envvar" as shown in Figure 3.[/vc_column_text][vc_single_image image="8110" img_size="full"][vc_column_text]Figure 3: Adding the environment variable HostIdConnected to the Envvar Window in Kvaser TRX.[/vc_column_text][vc_column_text]If we would like to see the value of the environment variables updated regularly in the Envvar window, we can tick the "Auto Refresh" check box. Having "Auto Refresh", enabled we can now restart the t program (Select Run->Stop and then Run->Start) and observe that the value of HostIdConnected is 1 at the start of the t program and switches to 0 at the same time as the message "Signal that we are ready to accept connections." is printed. This is just as we expected, see the t program listing for details.[/vc_column_text][vc_column_text]Now we add two more environment variables, Severity and Message, in the same way as we just have added the environment variable HostIdConnected.
When an environment variable is selected, a status row is showed where the Name, Type and Value is shown. The value box is labeled "New Value" which hints that you can enter a new value here and then click "Set Value" to update the value of the selected environment variable, see Figure 4.
The status row also shows a button named "Remove" which can be used to remove the selected environment variable from the Envvar window.[/vc_column_text][vc_single_image image="8111" img_size="full"][vc_column_text]Figure 4: Setting a new value to the environment variable Message in the Envvar Window of Kvaser TRX.[/vc_column_text][vc_column_text]Change the value of Message to 'My Message' and click "Set Value". Beside that the value is updated in the Envvar window, we also see that the running t program catches this change and writes "Severity: 0 -My message" at the console in the the lower pane of the Kvaser TRX window.
You can also try and change the severity. The change will be updated in the Envvar window, but since we do not have any hook for this environment variable in our t program, nothing will happen in the console area.
As an excersise, try and change the value of the environment variable HostIdConnected. Why does the Envvar window not show the new value? A hint is to take a look at the on envvar hook for HostIdConnected...
This ends this series about environment variables in t programs, hope you have enjoyed it. If you have any comments, contact us at [email protected].[/vc_column_text][vc_column_text]
Footnotes:
1 More about the CANlib SDK can be found at https://www.kvaser.com/developer/canlib-sdk/[/vc_column_text][/vc_column][/vc_row] [post_title] => Kvaser TRX and Environment Variables (3 of 3) [post_excerpt] => [post_status] => publish [comment_status] => closed [ping_status] => closed [post_password] => [post_name] => kvaser-trx-environment-variables-3-3 [to_ping] => [pinged] => [post_modified] => 2022-10-04 13:21:30 [post_modified_gmt] => 2022-10-04 13:21:30 [post_content_filtered] => [post_parent] => 0 [guid] => https://www.kvaser.com/?post_type=developer_blog&p=39870 [menu_order] => 0 [post_type] => developer_blog [post_mime_type] => [comment_count] => 0 [filter] => raw ) [5] => WP_Post Object ( [ID] => 8236 [post_author] => 5 [post_date] => 2015-09-15 09:01:12 [post_date_gmt] => 2015-09-15 09:01:12 [post_content] => [vc_row][vc_column][vc_column_text]Optimize protocol handling across five CAN channels using Kvaser USBcan Pro 5xHS’s scripting feature Kvaser AB has introduced a new five channel high-speed controller area network (CAN) to USB interface that allows users to monitor data from multiple CAN channels using just one device, with high time stamp precision. This device is CAN FD capable.[/vc_column_text][vc_column_text]- Five High Speed (ISO 11898-2 CAN) channels integrated in a single 26-pin HD D-SUB connector.
- Simultaneous operation of multiple devices.
- Includes 5 channel breakout cable.
- Quick and easy plug-and-play installation.
- Introduction to Environment Variables
- Accessing Environment Variables from CANlib
- Kvaser TRX and Environment Variables
envvar section in the t program.
In order to access an environment variable from CANlib you need a handle to the environment variable:
kvScriptEnvvarOpen (const int hnd, char *envvarName, int *envvarType, int *envvarSize)opens an existing environment variable and returns a handle as well as the type and size of the environment variable. In order for an environment variable to exist, the environment variable must have been defined in a t program that has been loaded in the device that the CAN channel handlehndpoints to.kvScriptEnvvarClose :: (kvEnvHandle eHnd)closes an environment variable (that has been opened withkvScriptEnvvarOpen()).
kvScriptEnvvarSetInt :: (kvEnvHandle eHnd, int val)sets the value of the environment variable pointed to by eHnd, which has been defined asint.kvScriptEnvvarGetInt :: (kvEnvHandle eHnd, int *val)retrieves the value of an environment variable defined as anint.kvScriptEnvvarSetFloat :: (kvEnvHandle eHnd, float val)sets the value of an environment variable defined as afloat.kvScriptEnvvarGetFloat :: (kvEnvHandle eHnd, float *val)retrieves the value of an environment variable defined as anfloat.
char with a length of up to ENVVAR_MAX_SIZE. In order to reduce the size of the data that is transferred, environment variables defined as array of char are exchanged using a start_index and data_len. This can be useful if you have divided the data and know what part of the data that you are interested in.
kvScriptEnvvarSetData :: (kvEnvHandle eHnd, void *buf, int start_index, int data_len)Sets a range of data bytes in an environment variable defined as an array ofchar.kvScriptEnvvarGetData :: (kvEnvHandle eHnd, void *buf, int start_index, int data_len)Retrieves a range of data bytes from an environment variable defined as an array ofchar.
Using Python and environment variables
Now it is time to test if we can talk to a device running the t program outlined in our first post in this series. In order to run this we need the wrappers for environment variables which is included in v5.12 of the CANlib SDK. A pre-release version is available at https://github.com/Kvaser/canlib-samples.[/vc_column_text][vc_code_raket language="python" header="Python sample code for accessing environment variables" code="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"][vc_column_text]Executing the above Python code results in the following printout on standard out:[/vc_column_text][vc_column_text]Waiting for device to be free... Requesting connection... Waiting for device to connect... Connected! Sending message 1 Sending message 2 Sending message 3 Sending message 4 Sending message 5 Sending message 6 Sending message 7 Sending message 8 Disconnect...[/vc_column_text][vc_column_text]Not very exciting, I agree, so in the last part of this series we will look at how to interact with those environment variables using Kvaser TRX, a light weight IDE for developing t programs for Kvaser devices.[/vc_column_text][/vc_column][/vc_row] [post_title] => Accessing Environment Variables from CANlib (2 of 3) [post_excerpt] => [post_status] => publish [comment_status] => closed [ping_status] => closed [post_password] => [post_name] => accessing-environment-variables-from-canlib-2-of-3 [to_ping] => [pinged] => [post_modified] => 2022-10-04 09:41:35 [post_modified_gmt] => 2022-10-04 09:41:35 [post_content_filtered] => [post_parent] => 0 [guid] => https://www.kvaser.com/?post_type=developer_blog&p=39847 [menu_order] => 0 [post_type] => developer_blog [post_mime_type] => [comment_count] => 0 [filter] => raw ) [7] => WP_Post Object ( [ID] => 8138 [post_author] => 5 [post_date] => 2015-09-04 11:44:39 [post_date_gmt] => 2015-09-04 11:44:39 [post_content] => Effective from 1st September 2015, Sven Sandén, Head of European Sales, will take over the role of Executive Vice President, Head of Global Sales. Meanwhile, Silvia Küller has been promoted from her position as hardware designer in Kvaser’s R&D department to become Head of European Sales and Managing Director of Kvaser Europe AB. The management changes will follow the departure of Michael Odälv, who leaves the company in September to become CEO at ArcCore, an embedded software provider to the automotive industry.
“Silvia’s long-term experience with Kvaser products and her technical background – she has an M.SC. in Electrical Engineering – will be of great benefit both to our customers, associates and our global sales team”, said Sven Sandén. He added: “I am looking forward to this new challenge and am confident that with our strong network of Technical Associates and Qualified Sales Representatives, we can continue to exceed customers’ expectations.” Commenting on the appointments, Lars-Berno Fredriksson, president of Kvaser AB said: “These changes reinforce Kvaser’s management structure for the long term and serve to highlight that whilst our technology comes first and foremost, we aim to nurture customer relationships to the best of our abilities. Sven and Silvia will continue to help us do just that.” He added: “Michael has made a significant contribution to the development of Kvaser’s commercial operations and we wish him the best in his new venture. With its ‘open’ software philosophy, ArcCore is much like Kvaser and the relationship could be mutually beneficial.”[post_title] => Management changes at Kvaser AB [post_excerpt] => Effective from 1st September 2015, Sven Sandén, will take over the role of Executive Vice President, Head of Global Sales and Silvia Küller has been promoted to become Head of European Sales. The management changes follow the departure of Michael Odälv, who leaves to become CEO at ArcCore. [post_status] => publish [comment_status] => closed [ping_status] => closed [post_password] => [post_name] => kvaser-ab-announces-key-management-changes [to_ping] => [pinged] => [post_modified] => 2022-09-29 04:14:15 [post_modified_gmt] => 2022-09-29 04:14:15 [post_content_filtered] => [post_parent] => 0 [guid] => https://www.kvaser.com/?p=8138 [menu_order] => 0 [post_type] => post [post_mime_type] => [comment_count] => 0 [filter] => raw ) [8] => WP_Post Object ( [ID] => 8193 [post_author] => 5 [post_date] => 2015-09-03 12:53:02 [post_date_gmt] => 2015-09-03 12:53:02 [post_content] => [vc_row][vc_column][vc_column_text]The Kvaser Memorator Pro 5xHS CB is a bare board version of the five channel high-speed controller area network (CAN) to USB interface and datalogger. ‘Bare board’ availability means that it is supplied without a housing and can thus be built into any system, whilst five CAN channels allows users to monitor and log data from multiple CAN channels using just one device. For industries such as mining, oil and gas, marine and other heavy industries, this small form factor board is an ideal complement to a data acquisition terminal or PC that requires custom housing. The Kvaser Memorator Pro 5xHS CB not only time synchronises the data transmitted and received across all five buses but also automatically synchronises with other Kvaser interfaces connected to the same PC, resulting in simpler, more accurate multichannel data capture. Crucially, the datalogging capability means that results from up to five CAN channels are recorded on one SD card, thus avoiding the difficult situation of trying to combine logfiles from two or three different memory cards. A special feature of the 5-channel Memorator Professional is its ability to run user-developed scripts. Like Kvaser’s Eagle interface and standard Memorator Pro 5xHS variant, the Memorator Pro 5xHS CB’s script functionality allows users to develop highly customised applications written in the Kvaser t programming language, such as CAN protocol converters, CAN gateways and advanced CAN logging functionality. This printed circuit board (PCB) has a standard USB female connector. The CAN connection is made using a standard 12-way connector on the top side of the board, plus a 10-way connector on the bottom side. An SD card reader sits on the top side, and power is derived from the USB connection, CAN and an on-board power supply. The Kvaser Memorator Pro 5xHS CB is compatible with J1939, CANopen, NMEA 2000® and DeviceNet, and will also be CAN FD upgradeable via firmware. The device is supported in CANlib, Kvaser’s universal software development kit, plus Kvaser Memorator Config Tool software. Visit Product Page >>[/vc_column_text][/vc_column][/vc_row] [post_title] => Memorator 5xHS CB unveiled [post_excerpt] => The Kvaser Memorator Pro 5xHS CB has now launched. It is supplied without a housing and can thus be built into any system, whilst five CAN channels allows users to monitor and log data from multiple CAN channels using just one device. [post_status] => publish [comment_status] => closed [ping_status] => closed [post_password] => [post_name] => memorator-5xhs-cb-unveiled [to_ping] => [pinged] => [post_modified] => 2022-12-23 02:03:58 [post_modified_gmt] => 2022-12-23 02:03:58 [post_content_filtered] => [post_parent] => 0 [guid] => https://www.kvaser.com/?p=8193 [menu_order] => 0 [post_type] => post [post_mime_type] => [comment_count] => 0 [filter] => raw ) [9] => WP_Post Object ( [ID] => 8196 [post_author] => 5 [post_date] => 2015-09-03 11:12:04 [post_date_gmt] => 2015-09-03 11:12:04 [post_content] => A team from the Chihuahua Institute of Technology in Mexico who are participating in Formula SAE are using a Kvaser CAN bus interface to transform their data gathering process. As part of Kvaser’s University Sponsorship programme, The Panteras (Panther) Racing Team have been supplied with a Kvaser Blackbird SemiPro HS/HS, a CAN-over-WiFi interface that allows the team to wirelessly transmit live data from the car to the paddock. In addition, Kvaser Leaf Light v2 is used in the team’s chassis dynamometer to port live data to the computer via USB. For 2015, the Panteras’ 2015 goal was to enhance the overall performance of each mechanical system, requiring real-time measurement of the dynamic behaviour of the vehicle under test. Previously, only a few variables were stored in the ECU’s datalog and data analysis proved slow and unresponsive for the team’s purposes. This year, a new team of electrical engineering students joined the project and added an evaluation board to the car to measure wheel speed and tyre pressure. Another board to measure temperature and barometric pressure is to be added shortly. The boards are connected to a common CAN bus, enabling Kvaser’s Blackbird to collect data wirelessly from two CAN bus networks. [post_title] => Formula SAE team transform data gathering with Kvaser interfaces [post_excerpt] => [post_status] => publish [comment_status] => closed [ping_status] => closed [post_password] => [post_name] => formula-sae-team-transform-data-gathering-with-kvaser-interfaces [to_ping] => [pinged] => [post_modified] => 2022-12-22 00:02:48 [post_modified_gmt] => 2022-12-22 00:02:48 [post_content_filtered] => [post_parent] => 0 [guid] => https://www.kvaser.com/?p=8196 [menu_order] => 0 [post_type] => post [post_mime_type] => [comment_count] => 0 [filter] => raw ) ) [post_count] => 10 [current_post] => -1 [in_the_loop] => [post] => WP_Post Object ( [ID] => 8770 [post_author] => 5 [post_date] => 2015-11-03 05:01:23 [post_date_gmt] => 2015-11-03 05:01:23 [post_content] => [vc_row][vc_column][vc_column_text]Leading Controller Area Network (CAN) interface specialist, Kvaser AB, is pleased to announce a strategic collaboration with Microchip Technology Inc., to support CAN with Flexible Data-Rate (CAN FD). Microchip will be integrating Kvaser’s CAN and CAN FD IP in future controller products destined for automotive and industrial applications. Kvaser benefits from Microchip’s extensive integration expertise and test capabilities. Kvaser and Microchip have an interest in working together to test and develop improvements to the Kvaser CAN FD Technology. CAN FD is an extension to the original CAN protocol as specified in ISO 11898-1 that responds to increased bandwidth requirements in automotive networks. CAN FD allows for a higher data rate and larger packet size that makes it well suited for data intensive automotive electronic applications.
Speaking about the partnership, Lars-Berno Fredriksson, president of Kvaser AB, said: “Kvaser is proud to support Microchip’s CAN FD developments with our CAN FD IP – this is great validation of the work we have been doing in preparation for CAN FD. As one of the first companies to participate in the CAN ecosystem, Kvaser offers deep knowledge and long experience in CAN and we are fully committed to supporting new developments, such as CAN FD.” Commented Orlando Esparza, Microchip’s CAN FD Product Line Marketing Manager: “Microchip recognizes that there will be a transition from CAN 2.0 to CAN FD in the coming years. Since 2012, Microchip has been working directly with automotive OEMs in all global regions to understand their requirements, timelines and expectations and are developing solutions to support their needs.” He added: “Microchip has a good and longstanding relationship with Kvaser, helping to minimize our device development cycle times. As a result, we have been able to quickly make design adjustments to meet ISO specification changes and requirements and plan to begin the roll out of controller products mid-2016. Microchip has already released multiple automotive approved physical layer CAN FD transceiver products. ”Microchip used preliminary CAN FD controller samples with ‘Kvaser inside’ to demonstrate its CAN FD capabilities at the 15th international CAN Conference (iCC) in Vienna, Austria on October 27 and 28, 2015. Kvaser staff were also presenting at the event, as well as demonstrating Kvaser’s CAN FD capable interfaces and dataloggers.
UPDATE: See more coverage appearing in online editions of :
- EETimes Automotive
- l'Embarque
- New Electronics
- Electronics Specifier
- Evertiq EU & Swedish version
- Electronik Tidningen
- Electronics Weekly and
- CiA Newsletter, among others.
youku