This post entry provides a detailed information about the EMVCo L1 certification process for contactless payment devices. The structure is the following: EMV Introduction Objective When a company is developing a POS device, there are some challenges to consider for a successful deployment in the market: The device needs to have a good performance to provide the client with a good user experience. Moreover, the device should be able to operate seamlessly with other devices and cards in the market in a secure and reliable way.   These key characteristics are tackled by the EMV specifications. Summarizing, EMV is a group of specifications for smart payment cards and terminals that were created by EMVCo to guarantee interoperability and acceptance of secure payment transactions. EMV stands for Europay, Mastercard, and Visa, the three companies that originally created the standard. These specifications are now managed by EMVCo, an organization of six members – including Mastercard, UnionPay, Visa, AmEx, Discover, and JCB.   EMVCo organization We can see in the figure below the structure of the organization. EMVCo is managed by the Board of Managers that consists of two representatives of every member of the organization. On top of the Board of Managers, the Executive Committee provides guidance on the group’s long-term strategy.     From a more technical point-of-view, it is organized in several Working Groups, each of them dedicated to specific topics. EMVCo also has the Associates Program, so key industry stakeholders can provide input and feedback to the Board of Managers, Executive Committee, and Working Groups.   EMV Technologies EMV specifications encompass a wide range of technologies, including: Contact chip technology, where smartcards and readers provide with cryptographical security advantages in comparison with the traditional magnetic stripe. EMV specifications also regulate contactless payment devices based on NFC technology.  Mobile Transactions where the mobile phone would play the role of a contactless device. The QR code technology, where the transaction can be made using a QR reader. Payment tokenization, that enables to perform transactions without compromising sensible card information. And other technologies like Secure Remote Commerce, 2nd Gen or 3-D Secure.   EMV Contactless specifications EMV Contactless specifications is now on version 2.6 but planning to move to version 3.0 by the end of the year.   The EMV Contactless specifications are structured in three books and the Contactless Interface Specifications that substitutes the Book D from previous versions of the specs. The Book A describes the overall architecture of the system, and the instructions involved in the communication between the entry point and the kernel. The Book B addresses the specifications regarding the Entry Point, which is the piece of sw in charge of the transaction pre-processing, or protocol activation among other tasks. Book C consists of 6 different levels for each of the kernels that are defined in the specifications. The EMV Contactless Interface Specifications describe the minimum set of functionalities that are required for the correct operation between the PICCs and the PCD.   In addition we will mention other relevant documents like: The PCD Test Bench and Test Case Requirements, that describes the test cases that are carried out by the testing laboratory in order to evaluate the devices. Note that there are 2 different documents, one for the Analog L1 tests and another one for the Digital tests. Another document describes the Device Test Environment, which is the software needed to control the device during the testing phase Another document describes the requirements regarding the Contactless symbol that should appear in all EMVCo Contactless POS in the market.   PCD L1 Type Approval The following diagram summarizes the process for the PCD L1 Type Approval:     In the first step the Product Provider shall submit a Request for Registration form to EMVCo. Once EMVCo reviews and accepts the form, the product provider will receive a contract that has to be signed. Upon reception of this contract, EMVCo will assign a product provider registration number. In the second step the Product Provider will choose a Test Laboratory and complete a document called Implementation Conformance Statement in which it provides detailed information about the device and its features. The third step is the Product Validation phase. In this phase the laboratory performs the product testing, where the device goes through a set of tests to evaluate the digital and analog performance. In a final phase and considering the test reports from the Laboratory, the Product Provider might decide to send the product to EMVCo for approval. In that case, EMVCo would analyze the tests reports and grant with a Letter of Approval in case the reports demonstrate sufficient product conformance.   In our case we are going to focus on the Analog L1 PCD tests.    EMV Analog L1 PCD Tests Environment Before going directly to the actual set of tests, it worth it to explain some components about the testing environment to better understand the testing procedure. We have the following elements: Device Test Environment Contactless symbol Positioning conventions EMVCo Reference PICC   Device Test Environment (DTE) The Device Test Environment is a software application that is used to control the device under evaluation during the whole testing process. This application has to be developed by the product provider and shall be implemented in compliance with a set of requirements defined in the specifications. The software is submitted to the test laboratory along with the samples of the device under certification. The DTE shall implement different applications or modes of operation that would be used depending on the testing scenario. These application are:   PCD Controls: It allows the test operator to execute single basic commands from the ISO14443 standard (Carrier ON/OFF, WUPA, WUPB,..) Pre-validation application: This application is used to test the communication of the device with a set of actual EMV compliant cards. Loopback application: It is used to test the device for the majority of the Analog and Digital L1 PCD Tests. In this case the reader is communicating with a Card simulator connected to a reference antenna. Transaction send application: This application can be used by the laboratory to evaluate the compliancy of the device with the waveform requirements defined for the Analog L1 PCD Tests. The main characteristic of this mode of operation is that the device sends a sequence of commands without waiting the responses from the PICC.   Contactless symbol The contactless symbol is the logo that you can see in the lower image. It helps the user identify the area in the Point Of Sale where he has to tap the card in order to trigger the transaction. This symbol has to be visible in the device surface or screen before and during the transaction. The Contactless symbol is extremely important for the testing procedure as it marks the reference point for all the positions that the device should be tested.   Using this reference point EMVCo defines an operating volume.   Positioning convention All test position are included in this operating volume. Depending on the test case, it will be run in one or more positions. Every position is expressed with a set of 3 coordinates or parameters, representing the height, the radius, and the angle respectively.     In the figure above you can see the operating volume along with the different values that each parameter can have.   EMVCo Reference PICC The EMVCo Reference PICC is the reference antenna used to communicate with the PCD under test. It has 4 ports and 2 jumpers that are used to configure the PICC for different purposes. For example, jumper 8 is used to select between linear and non-linear load depending on the type of tests that are performed. In the same line, the MOD IN port where a Signal Generator will inject a certain modulation to emulate a PICC response. The DC OUT port is used to measure the voltage level in the power tests and the LETI COIL OUT is used to measure the waveform tests among others. In the figure below you can also see the reference point of the antenna where the two white lines crossed:   Power tests The power tests are evaluated in all positions with the purpose of guaranteeing that the device is emitting enough field in all the positions. Depending on the height the limiting values will differ. In the figure below you can see the different planes with the respective limiting values.     The critical positions for the power tests are usually the outer positions for plane z=4 and z=3 where the voltage measured may not be strong enough to pass the tests. On top of that and depending on the transmission configuration used, it can also happen that the voltage measured at positions (1, 0, 0) and (0, 0, 0) can exceed the maximum level.   Waveform tests The purpose of the waveform tests is to evaluate the wave shape of the modulation used in the commands from the PCD. That way, if the wave shape fits with the requirements an EMVCo compliant PICC would not have any problem understanding the commands sent by the PCD.   The waveform evaluation for Type A modulation include the following test cases: t1 (TB121) Monotonic Decrease (TB122) Ringing (TB123) t2 (TB124) t3 and t4 (TB125) Monotonic Increase (TB126) Overshoot (TB127)     In the same way, the Type B test cases are the following: Modulation Index (TB121)# Fall time (TB122) Rise time (TB123) Monotonic Increase (TB124) Monotonic Decrease (TB125) Overshoots (TB126) Undershoots (TB127)     Reception tests The objective of the communication or responsiveness tests is to guarantee that the PCD is able to properly finish a transaction when the response of the PICC is in the limits of the specifications in terms of amplitude and polarity.   That way we find 4 different tests: Minimum load modulation, positive polarity (Tx131) Maximum load modulation, positive polarity (Tx133) Minimum load modulation, negative polarity (Tx135) Maximum load modulation, negative polarity (Tx137)   In the two figures below we can easily check the difference in the load modulation level between the oscilloscope capture for the Tx131 and the Tx133.     Other tests Besides the power, waveform and communication tests there are other tests included in the EMVCo Analog L1 Test cases. Here is the list of these other tests:   Carrier frequency (TAB112) Field resetting (TAB113) Power off (TAB114) Polling sequence (TAB115) FDTA PICC (TA139) BitRate (TA141 & TB141) BitCodingPCD (TA142 & TB142) BitCodingPICC (TA143 & TB146) BitBoundaries (TB147) TFSOFF (TB145 & TB148)   EMV Contactless Specs v3.0 The most important change is that the tests will no longer be carried out with one specific EMVCo reference PICC but with three. The first two are Class 1 antennas tuned to 16.1MHz and 13.56MHz, and the third reference PICC is a Class 3 antenna tuned to 13.56MHz.     This is important since the device will need to pass the test for 3 different antennas, making the testing process between 2 and 3 times slower and the tuning of the device more difficult than for the 2.6 version of the specs.   Other changes are a second different load for the linear load tests and the modifications of some waveform tests limits.   NXP Product portfolio for POS The product portfolio that NXP offers for contactless POS device includes three main chips: CLRC663 plus: EMVCo 2.6 ready chip compliant both for analog and digital L1 requirements. The CLRC663 plus is able to work with a transmitter current of 350 mA and a limiting value of 500 mA. This feature allows us to increase the field strength radiated and overcome power issues because of the design of the POS or the antenna.  PN5180: The PN5180 chip is also an EMVCo compliant frontend, that supports highly innovative and unique features like the Dynamic Power Control that optimizes the RF performance even under detuned antenna conditions. Other features are the Adaptative Waveform Control or the Adaptative Receiver Control to automatically adjust the transmitter modulation or the receiver parameters. These and many other features turn the PN5180 into the best NFC frontend in the market. PN7462: It supports contact and contactless interface in the same chip. It is an NFC controller, so includes an MCU with a configurable host interface. For the contactless interface, it implements similar functionalities as the PN5180, like the Dynamic Power Control, the Adaptative Receiver Control, and the Adaptative Waveform Control.   Further Information You can find more information about NFC in: Our NFC everywhere portal: https://www.nxp.com/nfc You can ask your question in our technical community: https://community.nxp.com/community/identification-security/nfc You can look for design partners: https://nxp.surl.ms/NFC_AEC And you can check our recorded training: http://www.nxp.com/support/online-academy/nfc-webinars:NFC-WEBINARS   Video recorded session

This MQX demo re-uses the standard MQX web_hvac demo with the GT202 Wi-Fi module setup in SoftAP mode. This example shows MQX RTCS, DHCP server, and web server running in the Kinetis MCU with the Atheros drivers. The client will be able to connect to the Soft Access Point, receive an IP address, and then use a web browser to view the web_hvac web pages.  The User Guide is included in the ZIP file.

Demo Advantages of i.MX6 Dual/Quad Plus Features Memory bandwidth utilization greatly improved On-die caches for GPU Multi-source GPU composition Featured NXP Products i.MX6DP i.MX6QP

This post entry provides a detailed description of how a Bluetooth Low Energy (BLE) pairing solution via NFC was developed using two of our reference development boards: The NTAG I 2 C plus kit for Arduino pinout The Freedom KW41Z board. This document has been structured as follows: NFC for easy one-tap pairing solution NFC pairing is one popular feature you can find in cameras, speakers, printer, routers, wearables and many more. Just bringing two NFC-enabled devices close together is all it takes to create a connection. Just to mention a few of examples, with just a swipe you can: Connect your phone to a wireless speaker. Connect your new devices to the home network. Connect accessories to the control unit. In all these scenarios… NFC and Bluetooth are a perfect combination, since the pairing process with NFC becomes: Faster compared to the traditional pairing methods. Easier, reducing technical support More reliable, making sure you connect to the right device. The technical basis for this “tap to connect” process is provided in the NFC Connection Handover specification running atop the NFC Forum protocol stack. It defines a framework of messages and data containers that allow bootstrapping of alternative (i.e., other than NFC) carrier connections in a standardized way. For this reason, NFC pairing solution offers a unified user experience and interoperability across different manufacturers.  NFC solutions to implement secure simple pairing There are two types of solutions recommended to add NFC pairing functionality to designs: NFC static pairing with NTAG 213 The first solution is embedding an NTAG 213 NFC label. In such a case, the pairing credentials need to be previously loaded in to the tag memory as well as in the device MCU during manufacturing. NFC dynamic pairing with NTAG I2C plus The second solution is embedding an NTAG I 2 C plus tag. In such a case, the pairing credentials can be dynamically updated by the device MCU during the product lifetime. In addition, other features such as an automatic wake-up field detection signal are possible. Precisely, the combination of a passive NFC interface with a contact I2C interface allows the product to behave as a tag and be read via NFC and to connect to a host or application processor via  I 2 C. In addition, NDEF messages can be generated and updated by the host MCU depending on the application requirements. Later, these NDEF messages can be read by any NFC phone, including iOS devices with the latest OS version. Hardware setup Mapping the previous diagram to the demo hardware, we have: The NTAG I 2 C plus tag, using the Arduino pinout kit The MCU, using Kinetis KW41Z. The applicatiob logic, which updates the NDEF contents based on different use cases. Some details about the hardware used in the next sections: Kinetis KW41Z The Kinetis KW41Z is a high integrated chip with multi-protocol radio features enabling Bluetooth Low Energy (BLE) and 802.15.4 radio protocols such as Thread. KW41Z has as large memory of 512KB that can support multiple radio protocols running in a single application instace and implements nine low-power modes and a wide operating voltage range (0.9V/4.2V), for optimum current consumption. Finally, the software support package includes: BLE, Thread and 802.15.4 generic network stacks, several sample demo apps, support for RTOS and full integration in MCUXpresso. The Kinetis KW41Z evaluation is supported with the FRDM-KW41Z development board. The board main components are: a reference crystal, an accelerometer, an Arduino header, some LEDs and buttons, a JTAG and OpenSDA connectors,and an external flash memory. NTAG I2C plus kit for Arduino pinout The NTAG I 2 C plus Arduino kit consist of two PCBs stacked together: The upper PCB is the antenna board with the connected tag The lower PCB is an interface adaptor board to the Arduino pinout. This kit can be used to connect and evaluate the NTAG I 2 C plus  into many popular MCUs with Arduino compliant headers, for example:  Kinetis (e.g. KW41Z, i.MX (e.g. UDOO Neo, i.MX 6UL, i.MX 6 ULL, i.MX 7D) and LPC MCUs (e.g. LPCXpresso MAX, V2 and V3 boards). The kit support package includes several software examples, including the BT pairing example based on KW41Z.  The OM29110ARD is a generic interface board which offers support for connection to any PCB implementing Arduino connectors. It exposes: 3.3V and 5V power supply pins. I 2 C , SPI and UART host interfaces. Generic GPIOs (e.g. to be used for field detect, interrupts, reset pins or others) As such, it allows the NTAG I 2 C plus to be plugged into Arduino devices seamlessly. Once the NTAG I 2 C plus  board is stacked on the KW41Z, the pining routing between the two boards is as follows. It uses:  The  I 2 C  interface pins. The 3.3V supply pin. One GPIO is routed for the field detection pin. The Vout, for the energy harvesting pin. The ground reference. BLE pairing with NFC on KW41Z and NTAG I2C plus This section details how the Bluetooth Low Energy (BLE) pairing with NFC on KW41Z and NTAG I 2 C plus works. The following block diagram is a simplified representation of the demo that shows: The Bluetooth and NFC interfaces The buttons and LEDs involved in the process. Starting BLE advertising After SW4 is pressed: The application goes from IDLE to searching mode, advertising the BLE device The LED 3 starts blinking in RED color. Writing BLE pairing NDEF message Once the BLE advertising is activated, the next step is for the KW41 to write the pairing message into the NTAG I 2 C  plus memory. After SW3 is pressed: The KW41 uses the  I 2 C interface with the NTAG I 2 C plus to load a pre-defined NDEF message with the BLE pairing details. At the same time, the LED 4 is set to GREEN. Pairing with the BLE device While the LED 4 is set to green, the BLE pairing message is exposed through the NTAG I 2 C plus  RF interface. During this interval, any NFC-enabled device: Can read out the NDEF pairing message. Pass the BT credentials to the Android system or the host processor. And automatically create a Bluetooth link according to the exchanged network credentials. In case of an Android system, no third-party implementation is needed on this part as long as the pairing message follows the NFC Forum specifications. Writing default NDEF message Once the pairing information is read out of the NTAG I²C plus, the KW41Z removes the pairing content and turns back to normal operation mode. In addition, in this specific demo, the NDEF pairing message is programmed to remain in the NTAG I²C plus memory for only ten seconds. After these 10 seconds: The green LED is switched off. And the pairing NDEF message is overwritten by the default NDEF about the NTAG I²C plus demo app. Video The following video shows how the Bluetooth Low Energy (BLE) pairing with NFC on KW41Z and NTAG I 2 C plus works. How to integrate NTAG I2C plus into FRDM-KW41Z hid_device sample project In this section, we describe, step by step, how NFC is integrated in an existing default demo application taken from the KW41Z support package.   FRDM-KW41Z startup In the board website, there are very clear instructions on how to get started www.nxp.com/demoboard/FRDM-KW41Z. For instance: How to test KW41Z. How to get the tools, in our case: MCUXpresso, and the SDK for KW41Z. How to import, build and runn the examples included in the SDK for KW41Z, in our case: the ones inside the wireless_examples folder Importing FRDM-KW41Z SDK and hid_device sample project After that, we import the FRDM-KW41Z SDK and we import the sample project used as a basis for adding NTAG I 2 C plus support, this is the hid_device example located under the wireless/Bluetooth folder. Importing NTAG I2C plus middelware The NTAG I 2 C plus  middleware can be easily imported as a new folder in the project tree using the MCUXpresso File / Import menu. Once imported, the internal structure of the middleware should have this structure: HAL_I2C: The HAL_I2C files support access to the Kinetis I 2 C interface. HAL_ISR:  The HAL_ISR files support the interrupt handling and callback registration for the Kinetis MCU. HAL_NTAG: The HAL_NTAG source files provide an API that allow you to communicate with the NTAG chip and implements the NTAG command set to perform memory access operations from the I 2 C interface.  For instance, this API can be used to perform: Read / Write memory operations on EEPROM and SRAM (for example, to read data, you just need to indicate the memory address and length of the data to be read) Read / Write access to NTAG I 2 C plus registers (for example, you just need to indicate the register macro to be read). Functions for enabling the pass-through mode and handling the data exchange between interfaces (setting the data transfer direction is as easy as using this function). HAL_TMR: The HAL_TMR files support access to the timing hardware of the Kinetis MCU. Adding / changing GPIO pin settings All pin and GPIO settings are defined within the pin_mux.c file. For our application, the I 2 C pins need and a GPIO for the field detection need to be enabled.  Regarding the host interface: the I 2 C  pins for NTAG communication are configured using the BOARD_InitI2C() function, it sets the required I 2 C  port (port 0 for this MC) and set the right mode for the clock (SCL) and data (SDA) lines. Regarding the field detection: it is defined within the source code even though it is not used so far. It is left defined for future use. Within the pin_mux.c file, there are other functions which initialize; for instance, the buttons, LEDs, etc. These functions are called during the hardware initialization. NTAG I2C plus software and hardware initialization We move to the main_application, where some pieces of code need to be added. All code that has been added, is inside the #ifdef NTAG_I2C clause. First, we added: The I 2 C_driver and the ntag_app header files . The ntag_handle handler declaration. Then, the HW initialization is performed calling I2C_initDevice and the NFC_Initdevice() function is called to fill the  ntag_handle software handler. HID_device demo extensions The BLE demo application is written in the hid_device.c file and the whole behavior is handled in this file. The C-code printout in the blue box  below shows the content of the BleApp_HandleKeys() function, which handles the BLE activity and the changes made related to the NFC use case. Similarly, all new code additions are within the #ifdef NTAG_I2C clause. Mainly, the BleApp_HandleKeys() function function was extended to: Copy the pairing NDEF message to the NTAG I 2 C plus chip when the button SW3 is pressed. Set the LED 3 to green while the pairing NDEF message is available. Start a timer counter from the moment the SW3 button is pressed In addition, when the time counter is expired (expiration was defined to 10 seconds): The memory content of the NTAG I 2 C plus chip is overwritten by default NDEF message. The LED 3 is set to off. NDEF message for BLE pairing definition The last part missing to cover the NFC integration into the KW41Z refers to the files created within the application to declare the NDEF pairing and NDEF messages. The NFC Data Exchange Format (NDEF) is the NFC Forum specification defining an interoperable, common data format for information stored in NFC tags and NFC devices. The spec also details how to enable tags to deliver instructions to an NFC device so that the device will perform a specific action when a particular tag is read (open a browser, initiate a phone call, pairing, etc.). Every NDEF message can be automatically processed by any NFC device and execute the appropriate action without requiring the installation of any customized software / application and independently of the hardware manufacturer. There are several NDEF record formats that you can use in your implementation. Each NDEF record indicates to the application processor which kind of payload the message carries. In our demo app, the default NDEF message used belongs to a smart poster record and the NDEF pairing message, follows the protocol defined in the NFC Forum connection handover specification. Going to the source code, two application files for the NDEF handling were created: The app_ntag.h declares the two NDEF messages used in this demo. The app_ntag.c, implements a function which writes the NDEF message into the tag. As mentioned, the NDEF used for this BLE pairing was built according to the Connection Handover and BT secure simple pairing specifications and rules. On the image below, we copied the declaration of the NDEF pairing message. This is actually the hex bytes that are written into the tag memory. To highlight son relevant parts: We find the capability container and the NDEF TLV. These two fields are used by the NFC device to detect if the tag is loaded with NDEF formatted data into a Type 2 tag (like the NTAG I 2 C plus). After that, we find the record type name. This is the MIME type for the Bluetooth out of band pairing (written in its ASCII representation). It is followed by the device Bluetooth MAC address, and the complete local name (Freescale HID). The terminator TLV In case you are interested to know more about the NDEF message structure, you can check the NFC Forum specifications The data (MAC address 00:04:9F:00:00:04 & device name FSL_HID) read by the NFC device is sent to the Bluetooth controller to establish the Bluetooth connection. Default NDEF message definition  The NDEF used as thedefault_ndef message consist of two records: The first record was built according to the SmartPoster specification from the NFC Forum, which describe how to store a plain message followed by an URL. The second record is what is called Android Application record. On the image below, we copied the declaration of the NDEF default message. To highlight son relevant parts:   As the NDEF BLE message, the first data fields we find correspond to the container and the NDEF TLV structure for a Type 2 Tag. Then, we find the smart poster record, which includes a text field. In this example, it codes the text “NTAG I2C Explorer”  and a URI field which codes a the NTAG Explorer kit website URL. After that, we find the Android application record, which is used to automatically launch the app  or, if the app is not installed, redirect the user to Google Play. Finally, the terminator TLV. After 10 seconds, the application removes the BLE pairing NDEF and replaces it by the above described NDEF message. This can be easily demonstrated by tapping the phone after these 2 seconds, and validate that the NTAG I 2 C plus demo is automatically opened. Video recorded session   Available resources BLE pairing with NFC on KW41 and NTAG I 2 C plus source code www.nxp.com/downloads/en/snippets-boot-code-headers-monitors/SW4223.zip NTAG I 2 C plus kit for Arduino pinout www.nxp.com/demoboard/OM23221ARD FRDM-KW41Z board www.nxp.com/demoboard/FRDM-KW41Z

Android Open Accessory support allows external USB hardware (an Android USB accessory) to interact with an Android-powered device in a special accessory mode. When an Android-powered powered device is in accessory mode, the connected accessory acts as the USB host (powers the bus and enumerates devices) and the Android-powered device acts in the USB accessory role. This ADK library is based on NXP Kinetis Microcontroller KL26, It implements some functions to communicate with android phone.  

NFC Tandem offers best of both worlds: An NFC reader and a passive connected tag sharing one antenna. A user can interact with the device when it is powered off (through the NTAG I²C plus); when the device is powered, it can interact with cards, P2P devices or other connected tags.                                                             NFC Tandem Uses Cases and Applications: One-touch pairing WiFi with phone, or card Bluetooth with phone, headset, speaker IoT network node commissioning User identification with badge or phone Authentication and configuration of consumable and accessory Zero-power parametrization Zero-power firmware update Zero-power diagnosis and maintenance NFC Tandem Demo: NFC Tandem concept is demonstrated using NFC Tandem reference board: The demo can run on either: UDOO Neo Download UDOO Neo demo image or Raspberry Pi Download Raspberry Pi demo image Video of the demo: <script src="https://players.brightcove.net/6153537070001/default_default/index.min.js"></script>(view in My Videos) NFC Tandem References: PN7150 High performance NFC controller, supporting all NFC Forum modes, with integrated firmware and NCI interface NTAG I²C plus NFC Forum Type 2 Tag with I²C interface NFC Tandem Documents: User Manual and reference schematics are attached to this document

Demo Needs for insuring availability of Electrical Power is increasing. Batteries are spreading into automotive, electrical storage systems. This demo will demonstrate the Battery Management Product Family from NXP.   Most scalable and comprehensive battery management solutions Automotive robustness and in-house manufacturing process Designed for Functional Safety   Featured NXP Product 14-Channel Li-ion Battery Cell Controller IC|NXP   Target Applications Automotive Battery Chargers and Management 48V battery applications High-voltage battery management systems (> 800 V) Industrial Energy Storage Systems Uninterrupted power supply (UPS) E-bikes, E-scooters   Block Diagram

The demo from FirstView Consultants is a wearable medical EKG alert with Wi-Fi connection to enable Cloud reporting and diagnosis. The demo consists of an SCM-i.MX 6SoloX V-Link device (i.MX6SoloX/PF0100/512MB LPDDR2) + Firstview V-Link Top board with 802.11 b/g/n, Bluetooth     SCM V-Link technology is ideal for handheld/space-constrained applications allowing customers to integrate vertically.   Features: AFIB detection with diagnosis and report to Cloud via Wi-Fi. Top board contains: Wi-Fi/BT module (802.11 b/g/n), NXP 6-axis sensor and SPI NOR Flash 1 GB. Base SCM device: 15.5x15.5mm. ____________________________________________________________________________________________________ Featured NXP Products: Single Chip System Modules (SCM)|NXP Partner Firstview Consultants NXP FXOS8700CQ 6-axis Sensor

This post entry provides a detailed description of how to port the NFC Reader Library to Kinetis K64F MCU. It is used a real porting example exercise to show the steps required to adapt the NFC Reader Library to a sample target MCU. The goal of this post is to serve as a guide for software developers requiring to port the NFC Reader Library to their MCU of choice for their designs. NFC Reader Library overview The NFC Reader Library is a software stack for creating and developing contactless applications for NXP’s NFC frontends and NFC controllers with customizable firmware. This library provides an API facilitates the most common operations required in NFC applications such as: reading or writing data into contactless cards, exchanging data with other NFC-enabled devices or emulating cards. The NFC Reader Library: It is based on a modular approach It has been designed with a flexible and multilayered architecture It is written in ANSI-C programming language It is supported in multiple design environments and platforms and it has been developed with a strong focus on portability. It is available for free download. The NFC Reader Library v5.02.00 currently supports: All our NFC frontends (CLRC663 plus PN5180) and PN7462 NFC controller. Their corresponding development boards, used as NXP reference HW (CLEV6630B, PNEV5180B, PNEV7662B) And built-in MCU support for LPC1769, LPC11U68, FRDM-K82F and Raspberry Pi. In addition, the release includes several examples to get familiar with the library and which can be used as reference for your developments and, it is also included an HTLM-based API documentation for all the components, which is generated from source-code annotations. NFC Reader Library architecture The NFC Reader Library is encapsulated into layers, differentiated by colors, and components, differentiated in boxes. From top to bottom, we have: The Application Layer (AL), which implements the command sets to interact with MIFARE cards and NFC tags. The NFC activity, which implements a configurable Discovery loop for the detection of contactless cards, NFC tags or other NFC devices. Next to it, the HCE and P2P components, for the emulation of Type 4 tags and P2P data exchange respectively. The protocol abstraction layer (PAL), which contains the RF protocol implementation of the ISO14443, Felica, vicinity and NFC standards. One level down, the hardware abstraction layer (HAL), which implements the drivers for controlling the NFC frontends RF interface and capabilities. Below, the Driver Abstraction Layer (DAL), newly introduced in the latest release, which implements the GPIO pinning, the timer configuration and the physical interface (BAL) between the host MCU and the reader IC. Finally, the OSAL module, in charge of abstracting the OS or RTOS specifics (handles tasks such as timers, events, semaphores and threads) This layered architecture is helpful for several reasons: The eleven software examples, the Application Layer (AL) and the Protocol Abstraction Layer (PAL) are HW-independent, so that can be used on top of any NFC frontend. The the Application Layer (AL), the Protocol Abstraction Layer (PAL) and the Hardware Abstraction Layer (HAL) are platform-independent, so that can run in any MCU without any additional change. In case the reader MCU is part of the built-in support, the examples can be directly imported and executed straight forward. On the other hand, in case the reader MCU is not supported by default, the major advantage is that only adaptations in the DAL and OSAL layers are required, while the rest of the layers can be used without any modification. The NFC Reader Library structure can be seen more clearly when imported in the MCUXpresso development environment. After completing the import wizard, all projects are listed in the “Project Explorer” window. As can be seen in the screenshot, it contains different folders: API documentation folder Driver Abstraction Layer FreeRTOS support The platform support (in the screenshot, corresponding to the LPC support) The software examples (11) The Reader Library implementation And the OS abstraction layer NFC Reader Library porting to FRDM-K64F steps In the existing NFC Reader Library v5.02.00 release there is no native support for Kinetis K64F. However, it is included a pre-compiled package for Kinetis K82F MCU. We use the K82F NFC Reader Library package as a reference project to start the porting to K64F MCU. This package can be downloaded from www.nxp.com/pages/:NFC-READER-LIBRARY. The steps required to port the library to Kinetis K64F are: Prearing the HW (i.e the pining between the Kinetis and the NFC reader board). Setting up the development environment (i.e workspace). Perfoming some changes in project configuration settings Performing some code modifications in the DAL and application code for adding Kinetis K64F support. NFC Reader Library porting to FRDM-K64F - Preparing the hardware The hardware used for this porting exercise is: A CLEV6630B board (CLRC663 plus) as an NFC transceiver  A FRDM-K64F board (Kinetis K64F) as host MCU, used to load and run the application logic. The CLRC663 plus evaluation board is connected by default to an LPC1769 µC via SPI. However, the board is made in such a way that the LPC1769 MCU can be bypassed to connect an external MCU easily. For doing so: Six resistors from the board need to be removed. These are highlighted in red. Use the SPI pin connectors available on the left hand side, on the board edge. Next, to connect the two boards together, the pining routing was done as follows: We use the Kinetis K64F jumper 2 pin line for the MOSI, MISO, chip select and clock lines of the SPI communication. The IRQ, interface selection and reset pins of CLRC663 plus are connected in jumper 1 pin line. And, one ground pin used for reference. Therefore no complex HW manipulation was required since all interfaces are easily accessible via dedicated headers or test points. NFC Reader Library porting to FRDM-K64F - Setting up the development environment Once the HW connection is prepared, we can move to setting up the development environment and workspace. Get the latest NFC Reader Library release From the software perspective, first we need to download the latest NFC Reader Library package. To do so: Go to NXP dot com slash pages slash NFC Reader Library (www.nxp.com/pages/:NFC-READER-LIBRARY) Go to the Downloads tab and click on the download button Click download on the NFC Reader Library for Kinetis K82Fpackage. Generate a downloadable SDK package for FRDM-K64F board As part of the NXP support, an SDK with drivers, middleware, RTOS demos and more is available for any of its Kinetis and LPC micros.We need to build the corresponding one to K64F SDK. For that: Navigate to www.mcuxpresso.nxp.com and select SDK builder option. Then, use the drop-down menus to customize your SDK configuration, middleware and optional software components be included in the package. Select Request build. In a few minutes, you will receive an email with a link to download the SDK package, very similar to the one showed in the figure below. Import the NFC Reader Library into MCUXpresso workspace Next step to configure the development environment is to import the library package in the workspace. The easiest way is to use the Quick Start Panel on the left hand side. Click on Import project from file system Then, browse the library package in your file system. Click Finish to import it all to your workspace. Install and link FRDM-K64F SDK into MCUXpresso workspace The last step is to import the K64F customized SDK we configured from the MCUXpresso tools. To do so: Just drag and drop the SDK into the installed SDKs tab of the MCUXpresso IDE. (It will appear in the bottom part, in the center) Import the SDK into the workspace and link it with the software examples. It will appear as another folder in the project explorer window. If the K64F SDK has been properly imported in the workspace, we should see a new drop-down menu for K64F. From there, we should select K64F and click Apply so that the memory details for K64F are set to the project example NFC Reader Library porting to FRDM-K64F - Project configuration changes At this point we have the hardware and the workspace for software development ready. In this step, we will start porting the NfcrdlibEx1_BasicDiscoveryLoop  software example provided as part of the NFC Reader Library release. Select FRDM-K64F SDK in the project MCU settings One of the first configurations to be changed is the project MCU settings. These settings indicate which target host device is running the application code. These settings can be found if: You right click on the project example > Properties In the left-hand list of the Properties window, open “C++ build” and select “MCU settings” In the right-hand panel, we can observe the corresponding settings for K82F micro. The left figure indicates the project configuration settings used by the default SW example prepared for K82F while the right figure indicates the final project configuration settings used by the SW example ported to K64F. Define FRDM-K64F SDK preprocessor symbols in the project After that, we need to change the compiler preprocessor settings, which can be found in C++Build > Settings. In the project examples of the NFC Reader Library, the conditional directives like #ifdef and #ifndef are used to include or exclude portions of the code from the actual compilation. The conditional codes are included in the program compilation only if the MACROs are defined in the project compiler preprocessor settings. In the left side we can see the defined macros for the original project. Among them, includes one which defines that the HW used is PN518 and K82F board. Therefore, in the ported project, we need to replace the macros corresponding to K82F with the new ones corresponding to K64F.  For instance, the PHDRIVER_K64_CLRC663 macro includes in the compilation the files related to the new HW used in the ported project (for the board pin and GPIO config, SPI settings or timers). Precisely, these files are included inside BoardSelection.h file in the Driver Abstraction Layer (DAL). Add include paths for FRDM-K64F SDK files When including header files into our project, the compiler must be told which directories must be searched to find those files. To do this: Open the project properties. In the left-hand list, open “C++ Build” and Select “Settings”. In the right-hand pane, choose the “Includes” section. Click the “Add icon”. In the left figure, we see the compiler include paths for the K82F SDK of the original example. In the ported example, the K64F SDK sources will not yet compile since we did not tell the compiler about all the new include paths. Therefore, we need to add the new include paths pointing to the K64F SDK and put them into the MCUXpresso IDE project. In the right figure, you can see the paths we included for this purpose. Mainly, these paths reference to the board system init, board drivers, CMSIS files and debug utils. Add include path for FRDM-K64F MCU assembler The last MCUXpresso settings to be changed is in the MCU Assembler. This can be found in the right-hand panel, choose the “MCU Assembler” and select “General”. In the original source code, a path is used to the K82F SDK. In the ported example, we just need to remove the previous include path and replace it with the corresponding one pointing to the K64F SDK in our workspace. NFC Reader Library porting to FRDM-K64F - Code changes So far, we have the HW, the development environment prepared and the project configuration settings changed. At this point, there are only a few code changes to be done before the porting is completed and the software example can be run in K64F. DAL driver adaptation for FRDM-K64F The layered architecture of the NFC Reader Library makes porting easier since only the lower drivers need to be adapted. This driver includes functions for: The physical link connection establishment between the CLRC663 plus and K64F The init functions for timers and interrupts so they are correctly used by the application layer. Going to the NfcrdlibEx1-BasicDiscovery loop project structure, it contains several folders. If we open the DAL > board folder, we can observe one source file per each supported platform (LPC with PN5180 and CLRC663, and the same for Raspberry Pi and Kinetis K82F). Our task for the porting would be to create an equivalent source file for the new supported board, the K64F together with the CLRC663 (e.g. Board_FRDM_K64FRc663.h). This file includes The related board pin and GPIO configurations The SPI configuration The timer configuration In addition, we need to include the board, pin_mux and clock config files. Use SDK examples to get FRDM-K64F board specific configuration Implementing these board specific files, in some cases, could be time consuming and may require experience. However, you do not need to do so but rather use the existing source files. For that, you can use any of the existing SDK software examples. You can easily import one SDK example by: Clicking the “Import SDK” example in the quick start menu > select the FRDM-K64F board. Selecting the demo example. Each example application has its own unique copy of the board, pin mux, and clock config files that you can reuse for the porting (Note: this process could be different depending on the MCU used). Add FRDM-K64F macro definitions in the source code Next, along the project tree, we need to add the #ifdef directives, indicating that K64F board files that need to be compiled. This is the case for: The BoardSelection.h file The ph_NxpBuild_App.h, which links the board with the reader IC by enabling the CLRC663 plus module in the HAL layer. The ph_AppInit.h so that the board is initialized when the reader device boots. Add FRDM-K64F CPU initialization code The ph_AppInit.h  file takes care of the code initialization and code specific to the HW used to run the example. As part of this ph_AppInit.h file, there is a function in charge of initialization the host MCU. Here, we need to implement the corresponding function for the K64F init, based on the SDK example source code selected earlier. If we look within this routine, we actually find functions for: Configuring the MCU clocks. Configuring the MCU pins. Configuring the interrupts (PIT). NFC Reader Library porting to FRDM-K64F: NfcrdlibEx1_BasicDiscoveryLoop execution After following the previous steps, the source code is succesfully ported to K64F. The following video demonstrates the correct execution of the NfcrdlibEx1_BasicDiscoveryLoop example in FRDM-K64F host MCU connected to CLRC663 plus NFC frontend (CLEV6630B). The video includes a webcam, which records the HW, including all the witing wiring between the K64F and the CLRC663 plus antenna. After the code is built and compiled, the video shows how some tags are tapped to validate that the example is working as expected (tag's UIDs are displayed in the MCUXpresso console). . General considerations to port the NFC Reader Library to your target MCU Overall, the general steps required to port the NFC Reader Library to your target MCU are: Adapt the MCU drivers to the DAL layer in the NFC Reader Library. This typically includes: timers, interrupts, pining and host interface configuration between the NFC reader and host MCU sides. Adapt the OS layer (i.e. you might need to port the FreeRTOS or to your target OS platform). Adapt the source code examples: project settings (macros, include paths, MCU configuration) and perform the required code modifications (Code for HW initialization, board files, etc). Available resources NFC Reader Library:  www.nxp.com/pages/:NFC-READER-LIBRARY CLRC663 plus: www.nxp.com/products/:CLRC66303HN CLRC663 plus development kit: www.nxp.com/demoboard/OM26630 FRDM-K64F board: www.nxp.com/demoboard/FRDM-K64F Video recorded session

About this demo This demo is based on the Wireless UART example from the SDK available on Welcome | MCUXpresso SDK Builder selecting the QN908X board.  The main idea of this demo is to be able to send commands from one device to another, it could be from a QN9080DK, a phone using our NXP application: IoT Toolbox or even an FRDM-KW41Z, this is possible because of the BLE protocol used in all our devices. The end-device used is a QN9080DK, this board receives the message, does parsing and triggers a PWM function using the values sent from another device. This signal can be used in different applications, typically controlling smart lighting brightness and color, speed of motor controls and audio or video amplifiers. The goal of this demo is to implement a task for our FreeRTOS scheduler in order to be able to control a PWM while the BLE connection is still running and receive new incoming messages.   Video Limitations We only interpret ON, OFF and a string of values for our 3 signal outputs. The string of values has to be in the following syntax: rXXX,gXXX,bXXX. An example of this could be r255,g130,b200. The max value should be 255 in order to achieve 100% of the duty cycle, for this example, we are using is at 100 Hz. The connection is not using pairing or bonding modes, so no device information is saved on the non-volatile memory due to this if the connection is lost we need to follow the initial connection procedure. The amount of bytes that can be sent is limited by the macro: #define gAttMaxMtu_c in the ble_constants.h file from the project, we recommend to leave it as it is.   Useful Links Useful documentation is available in the SDK previously downloaded: <SDK Installation folder>...\SDK_2.2.1_QN908XCDK\docs   Link Description https://www.nxp.com/webapp/Download?colCode=QN908x-DK  QN908xDK User’s Guide Welcome | MCUXpresso SDK Builder  SDK Builder site Wireless Connectivity  NXP Wireless Community Connectivity Software: Implement tickless mode in FreeRTOS  Document for implementing a new task using OSA Abstraction layer of FreeRTOS https://www.nxp.com/docs/en/nxp/data-sheets/QN908x.pdf QN908x Datasheet for pins functions   Required Items Link Description QN908x: Ultra-Low-Power Bluetooth Low Energy System on Chip (SoC) Solution | NXP  It is required at least one as an end-point. Oscilloscope  An Oscilloscope to visualize the PWM. Hardware Diagram Step-by-Step Guide Download de QN908x SDK Download the attached .zip file. Import it into MCUXpresso, for the end node you should only use the qn908xcdk_wireless_uart_peripheral project. If you want to use a second QN board to send the commands it is required to also import the qn908xcdk_wireless_uart_central project. Once the projects are imported, we need to flash each board with a project and connect the PA9, PA10, and PA18 pins to our oscilloscope in order to visualize the signal. Connect the USB cables to the computer and open Teraterm with the following values: 115200, 8 bits, none,1 bit, none. Press the RESET Button (SW3) of the Peripheral board Press the Button1 (SW1) after the message: "Wireless UART starting as GAP Peripheral, press the role switch to change it.", an "Advertising" should appear. If a second QN board is used (central), we need to open a second Teraterm session and set it to the same Serial configurations from point 5. If an Android phone is used we need to have the IoT Toolbox application installed and select the Wireless UART example and connect to the Peripheral board using the interface. To pair the Central board to the Peripheral it is required to press the RESET Button (SW3) of the Central board while the Peripheral board is advertising and then Push the Button1 (SW1). Once the boards are connected, we need to paste the message to our terminal in order to be sent as one message. The message should be seen in the other board terminal. Send "ON" to activate the PWM functionality. Send "r255,g128,b64" to set the PWM pins to 100%, 50%, 25%. This signal must be displayed at 100Hz on the oscilloscope. Send "OFF" to deactivate the PWM functionality.   Further Information The Demo is based on the Wireless UART example, The BleApp_ReceivedUartStream function is modified to compare de received strings. The getValuesRGB converts the string into integer values to be assigned to the global variables red, green, blue. Inside getValuesRGB we use the OSA abstraction layer for FreeRTOS to create the task using: OSA_TaskCreate and creating the task named: vfnTaskPWM. vfnTaskPWM configures the timer and initializes the PWM values using the CTimer driver functions and starts the CTimers.     Results 1. After the QN9080 is flashed and in Advertising mode, we have to connect our Central device, Which in this case is an Android phone. In or Teraterm we should be able to see this message: 2. Then, we get the Connected status from our devices and we should be able to send the ON command and the RGB values, Teraterm indicates the integer values and the string received.         3. When we send the OFF command the PWM signals should be 0 V.   4. Here is another example:    

This NXP demo is a combination of two demos running on the MIMXRT1050-EVK board, showing USB Type-C power delivery and a GUI with touch interface running on the i.MXRT1050 MCU. See video of demo below.   First example is USBPD demo from the MCUXpresso Software Development Kit (SDK) for the kit. This SDK can be downloaded from https://mcuxpresso.nxp.com. The SDK USBPD project is included at \SDK_2.3.0_EVK-MIMXRT1050-OM13588\boards\evkmimxrt1050_om13588\usb_examples\usb_pd. This demo uses the FreeRTOS version. Generic description of this demo is included here in the SDK at \SDK_2.3.0_EVK-MIMXRT1050-OM13588\docs\usb\MCUXpresso SDK USB Type-C PD Stack User's Guide.pdf. Second example is a washing machine GUI using TouchGFX. This example is provided by Draupner Graphics with source code in their TouchGFX release, with more details shared here: https://touchgfx.com/nxp-semiconductors/i-mxrt1050-display-kit/ Here is a video overview of using this combined demo: Hardware Requirements ===================== For the full demo shown in the video, the following hardware is required: MIMXRT1050-EVK - eval kit for i.MXRT1050 MCU LCD - comes with MIMXRT1050-EVK OM13588 (x2) - USB Type-C shield board, two shields required FRDM-K64F - Kinetis K64 Freedom development board 0.1" female headers for Arduino connectors, not included Cables: USB Type-A to male micro-B (2 cables needed) USB Type-C male to Type-C male 9V power supply with barrel connector (2 supplies needed). Come with OM13588 kits Software Details ================ This demo was built with the following software versions: IAR Embedded Workbench for ARM v8.20.2 MCUXpresso SDK_2.3.0_EVK-MIMXRT1050-OM13588, Build Date: 2017-12-11 MCUXpresso SDK_2.3.0_FRDM-K64F-OM13588, Build Date: 2018-01-10 TouchGFX v4.9.0 Setup Video NXP Recommend Product Link USB Type-C Shield Board for Kinetis® Freedom and LPC Boards OM13588: USB Type-C Shield Board | NXP  i.MX RT1050 Evaluation Kit i.MX RT1050 Evaluation Kit | NXP  Freedom Development Platform for Kinetis® K64, K63, and K24 MCUs FRDM-K64F Platform|Freedom Development Board|Kinetis MCUs | NXP 

Demo Owner David Lopez This demo is an overview of our power management simulation and validation tools. Our tools will help you accelerate power management validation with ISO 26262 compliance. Through this demo you will discover how NXP develop innovative validation tool to cover multiple use case, and accelerate product validation in line with ISO26262. The leading device use to develop this tool is MC33908, System Basic Chip with DC/DC and highest functional safety level.  In addition this tool is also covering the validation of MCU and SBC attachment.  This tool contain a database made through the collection of different car OEM "non-ISO" pulse with fast execution.   Features Transient simulation tool platform Accelerate power management validation with ISO 26262 compliance Global OEM use cases database Featured NXP Products Analog and Power Management|NXP

Demo This solution showcases the i.MX 6QuadPlus along with the MMPF0100 Power Management to enable the 2D/3D cluster, infotainment and rear view camera.      Features: High performance smooth 3D graphics based on the i.MX 6QuadPlus applications processor running on Linux. On the fly rendering of the infotainment menu. Seamlessly integrate extremely responsive instruments and highly complex 3D content Optimal usage of the CPU and GPU to achieve high-end graphics on the power effective and system cost effective i.MX Switch between HD video playback and the rear view camera on the secondary display Menu can be blended over the map (BG layer) using transparency   _______________________________________________________________________________________________________________________ Featured NXP Products: Product Link i.MX 6QuadPlus Processor i.MX 6QuadPlus Applications Processors | Quad Arm® Cortex®-A9 with extreme graphics performance and enhanced power manag…  i.MX 6DualPlus Processor i.MX 6DualPlus Applications Processors | Dual Arm Cortex-A9 for extreme graphics performance| 1.2 GHz | NXP  14-Channel Configurable Power Management IC 14-Channel Configurable Power Management IC | NXP  SABRE for Automotive Infotainment Based on the i.MX 6 Series SABRE|Automotive-Infotainment|i.MX6 | NXP    _________________________________________________________________________________________________________________________   Screen shot 1: Cluster with 3D maps Real-Time 3D map (created in Blender): 640 abstract buildings. 20 different building types. 3 “special” buildings. One building type. 5x5 map grid. Dynamic, directional lighting. Calculating and updating car chase camera every frame. Smooth 3D animations even at 30 Hz. This is no video!     Screen shot 2: Secondary Display playing Video or RearView Camera

Demo The demo session focuses on demonstrating the transport of human voice over the Bluetooth Smart protocol on Kinetis Wireless platforms running the Kinetis Bluetooth Low Energy stack. The intended setup is made up of two Kinetis Wireless KW41Z evaluation boards connected to an audio codec board with a headset (headphones + microphone) connected at each end. The audience can use the headsets for a full duplex voice communication experience. This demo session is aimed at showcasing the performance of the Kinetis KW41Z platform Demo Features Full duplex voice samples transport over Bluetooth LE transport using Kinetis KW41Z enabled with the Kinetis BLE v4.2 stack SGTL5000 audio codec for sample processing and Kinetis K24F for used for compression Interactive component through a pair of headsets for demonstrating the full duplex voice capabilities NXP Recommends Product Link Kinetis® KW41Z-2.4 GHz Dual Mode: Bluetooth® Low Energy and 802.15.4 Wireless Radio Microcontroller (MCU) based on Arm® Cortex®-M0+ Core https://www.nxp.com/products/wireless/thread/kinetis-kw41z-2.4-ghz-dual-mode-bluetooth-low-energy-and-802.15.4-wireless-radio-microcontroller-mcu-based-on-arm-cortex-m0-plus-core:KW41Z?&fsrch=1&sr=1&pageNum=1 Ultra-Low-Power Audio Codec https://www.nxp.com/products/audio/audio-converters/ultra-low-power-audio-codec:SGTL5000?&fsrch=1&sr=1&pageNum=1 Kinetis® K24 120 MHz MCU Tower® System Module TWR-K24F120M|Tower System Board|Kinetis® MCUs | NXP 

Demo Owner: Mark Houston   Kinetis V series is a family of devices targeting motor and power control applications for the mass market with a strong focus on enablement. See two elements of that story: a product benchmark showing relative product performance and the Kinetis motor suite -- a tool that speeds your development time to market.       Features Motor speed capabilities Comparison to standard controllers Smooth transitions Featured NXP Products Kinetis V Kinetis V1 Kinetis V3 Kinetis V4 Development Tools Kinetis Motor Suite Design Resources Kinetis Motor Suite Fact Sheet

Demo This demo showcases an OpenWRT based Thread Border router running on i.MX6UL and the various options to configure and use routing, firewall and out of band commissioning for Thread networks in combination with WiFi, Ethernet and NFC. OpenWRT is an open source Linux distribution for embedded devices specifically designed for residential gateways and routers. When enhanced with the Kinetis Thread protocol it offers the perfect solutions for creating a Linux based Thread Border Router Large and dense mesh network consisting in 64+ Thread nodes Each node is router capable, network decides dynamically which nodes become active routers Multiple application functionality run in parallel: Device addressing and identification Lighting demonstration with multicast Occupancy sensing demonstration Border Router with Network management web GUI   Features: Application layer communication based on generic CoAP framework CoAP messaging aligned with current ZigBee or OIC frameworks Kinetis KW2xD and Kinetis KW41 ARM Cortex-M4/M0+ MCUs with large on-board memory (up to 512KB flash/128 KB RAM) enable multiple applications to run on a common Thread IP network fabric. 1 i.MX6UL ARM Cortex-A7 with Kinetis KW2xD Linux Border Router used for interfacing with network management GUI Network management and interoperable Thread diagnostics framework used to monitor node state Nodes are enabled for OTA Updates _____________________________________________________________________________________________ Featured NXP Products: Product Link i.MX6UltraLite Evaluation Kit i.MX6UltraLite Evaluation Kit | NXP  Freedom Development Platform for Kinetis® KW2x MCUs FRDM-KW24D512|Freedom Development Platform|Kinetis | NXP  _____________________________________________________________________________________________

Demo         This was a super fun project to work on and is popular around the office and on the road.  Now I have two of these for a truly amazing barrage of Nerf darts!  It's also always a lot of fun to tear things down and the Nerf gun had some cool plastic work and the shooting mechanism is more simple than what I originally guess.  But I digress, this post is about how you can build one of these yourself.  Please leave any questions or comments in the section below and I will try to answer and make refinements to this guide as we go.   The shopping list (aka Bill of Materials or BOM)   If you shop around you might be able to find better prices or substitute parts.   Type Part Qty Price URL UBEC HKU5 1 $             5.33 http://www.hobbyking.com/hobbyking/store/__16663__HobbyKing_HKU5_5V_5A_UBEC.html LiPo TURNIGY 2200mAh 3S 20C 1 $             7.89 http://www.hobbyking.com/hobbyking/store/__8932__Turnigy_2200mAh_3S_20C_Lipo_Pack.html Servo S5030DX 1 $           28.63 http://www.hobbyking.com/hobbyking/store/__18862__Hobbyking_S5030DX_Digital_MG_Servo_X_Large_HV_164g_0_20s_30kg.html Servo HK15138 1 $             3.12 http://www.hobbyking.com/hobbyking/store/__16269__HK15138_Standard_Analog_Servo_38g_4_3kg_0_17s.html Relay PCB COM-11041 1 $             3.95 https://www.sparkfun.com/products/11041 Relay Components Various 1 $             3.00 https://www.sparkfun.com/wish_lists/36307 Nerf Gun Nerf Dart Tag Swarmfire Blaster 1 $           44.99 http://www.toysrus.com/product/index.jsp?productId=11267568 Controller FRDM-K64F 1 $           29.00 FRDM-K64F | mbed Servo Arm Double Servo Arm X-Long 1 $             3.20 http://www.hobbyking.com/hobbyking/store/__19468__CNC_Alloy_Double_Servo_Arm_X_Long_Futaba_.html Servo Arm Heavy Duty Alloy Arm 1 $             5.63 http://www.hobbyking.com/hobbyking/store/__18350__Heavy_Duty_Alloy_1in_Servo_Arm_Futaba_Red_.html Servo Linkage Alloy Pushrod with Ball-Link 65mm 1 $             2.10 http://www.hobbyking.com/hobbyking/store/__25834__Alloy_Pushrod_with_Ball_Link_65mm.html Lazy Susan Shepherd 6 in. Lazy-Susan Turntable 1 $             4.49 http://www.homedepot.com/p/Shepherd-6-in-Lazy-Susan-Turntable-9548/100180572#.UYk5UqLql8E Metal Rod 3/8 in. x 36 in. Zinc Threaded Rod 1 $             2.87 http://www.homedepot.com/p/3-8-in-x-36-in-Zinc-Threaded-Rod-17340/202183465#.UYk5pqLql8E Frame 1/2 MDF 2ftx4ft 1 $           10.45 http://www.homedepot.com/p/1-2-in-x-2-ft-x-4-ft-Medium-Density-Fiberboard-Handy-Panel-1508108/202089097?N=btn1#.UYk6CqLql8E   The build   Two main pieces to construct in this phase.  The base turret and the actual hacking of the Nerf gun.   All your base.. The base of the turret is pretty rudimentary, lot's of room for improvement here.  I used 1/2 MDF and some carpentry skills.  Here is some instruction on how to build a MDF box.  Atop the box is a lazy Susan (ball bearing ring) so that the top-plate can rotate smoothly.  We considered leaving this element out, but worried that it would put to much strain on the servo.   On the subject of servos, a few tidbits of wisdom for you as you build this thing.  First, the left/right servo needs to be dead center of the lazy susan, if your off too much things will start to bind which is not good for your servo.  Second, I used large higher torque servos which cost a bit more, they might be overkill, but it certainly performs well.   I did a quick dimensionally accurate rendering of the design in Sketchup. Files are here.   Hacking the Nerf   Now for the fun stuff.   There is no shortage of screws with this Nerf Gun.  So get out your Phillips screwdriver and go to town. There are two electrical systems in the Nerf that we are going to tap into.  One is the power switch and the other is the electrical trigger. This is the electrical trigger.  The trigger goes to our relay, which is either on or off.  We did try at first to use a 7.2V R/C car battery, but the Nerf draws too much power and didn't fire.  Going up to a 11.1V LiPo fixed that right up. This is the power switch. In Nerfinator 1.0 everything was hardwired together, which prevented us from completely pulling the Nerf from the base and made repairs difficult to say the least.  Nerfinator 2.0 we put this handy connector which allowed us to completely and easily remove the Nerf from the base.  Shipping this thing around the country will take a toll on it!  On that subject, Nerf 1.0, stopped cycling to the next position for us at the Austin Mini Maker Faire.  After a through inspection of the operational mechanics inside the Nerf (really cool BTW) it was a little bitty spring that was causing the piston not to fully retract.  We replaced the spring with 1/2 a ballpoint pin spring and to our surprise it all worked again. Electrical Connection Diagram   Added High-Level Block Diagram.  Need to add pinouts.  You'll have to read the code for now to figure it out.     Code   Mbed was the programming tool of choice for this build.   Receive Side (RX) - The receiver is the base side.  This one takes input from the remote and controls the servo movement. NerfGun_nRF24L01P_RX - a mercurial repository | mbed Transmit Side (TX) - The transmitter is the remote side.  This one senses the users movement (accelerometer) and sends that data to the base station. NerfGun_nRF24L01P_TX - a mercurial repository | mbed   Finishing Touches   In the first passes of this build we just used a bare development board as the remote control.  We found that when given the remote they would not orientate it properly, so 3D Printed Controller STL files   Development Team John McLellan - Amplification/Motivation Clark Jarvis - Software/Hardware Iain Galloway and Angus Galloway - Design and print of controller FRDM_case_sunday_PART_REV_001.STL.zip

The Attach demo consists of a 3 board stack up using the Arduino connectors on the Kinetis FRDM-KL26Z board. The demo runs from a Li Ion polymer battery and consists of 1x FRDM-KL26Z board, 1x FRDM-BATT board (including battery and loudspeaker) and 1x Arduino LCD touch screen board. The code builds using either CodeWarrior V10.6 or IAR EWARM V7.20.2. The software uses eGUI to drive the Arduino LCD and runs demos for the following Sensors - FXOS8700 (combined 3-axis Accelerometer and Magnetometer) and FXAS21000 (3-axis MEMs Gyro). The demo also includes 7-element eCompass code for which full source code is available. Finally, the board also uses the MC34673 1.2A charger for Li Ion batteries, charging is accomplished via either of the USB ports on the FRDM-KL26Z. All datasheets, schematics, source code and bill of materials are included in the zip archive. NOTE: software update which now includes 10-element eCompass software and Kalman filtering code creating a far more accurate eCompass solution. Recommended Products Product Link Freedom Development Platform for Kinetis® KL16 and KL26 MCUs (up to 128 KB Flash) FRDM-KL26Z|Freedom Development Platform|Kinetis® MCU | NXP 

Demo Owner: b14714 The motor control development toolbox is a comprehensive set of tools that plug into the MATLAB™/Simulink™ model-based design environment for rapid application development on MCUs.  The SFIO Toolbox is a new addition that can control Simulink system models by SFIO algorithms running directly on NXP DSC and Kinetis MCU hardware. NXP FreeMASTER debug monitor and data visualization tool interfaces provide an interface to monitor signals in real time for data logging and signal calibration. Features The motor control development toolbox is a comprehensive set of tools that plug into the MATLAB™/Simulink™ model-based design Auto code generation straight to the Micro. NXP developed a library and embedded target to interface with MATLAB and SimuLink Customers can directly go from the model based environment to the MCU without having to write C code by hand Featured NXP Products Motor Control

  Introduction   In this document, we are focusing on the usage of two functions of FreeRTOS: Creation of tasks and the use of queues as a way to trigger a generic functionality in our application. NXP’s SDK abstraction layer for the QN908x is intended to give the customer a simpler way of FreeRTOS usage and control functionalities. Hardware Requirements: QN9080DK Software Requirements: MCUXpresso IDE v11.1.0 or newer QN908XCDK SDK with BLE stack and examples (It can be downloaded from the SDK Builder) This document is based on the Wireless UART example from the SDK. Setting up the required variables and definitions Import the FreeRTOS version of the wireless_uart example included in the QN9080’s SDK.   Note: Be sure to select UART as your debug console.    2. In order to change the default role of the QN9080 board it is required to change the definition of the mGapRole variable, from gGapCentral_c to gGapPeripheral_c in PROJECT_FILE_NAME > source > wireless_uart.c > BleApp_Config(). //wireless_uart.c //static void BleApp_Config(void) { /* By default, always start node as GAP central */ //mGapRole = gGapCentral_c; mGapRole = gGapPeripheral_c; (void)Serial_Print(gAppSerMgrIf, "\n\rWireless UART starting as GAP Peripheral, press the role switch to change it.\n\r", gAllowToBlock_d); mAdvState.advOn = TRUE; mScanningOn = FALSE; //...}‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍    3. It is important to change the macro value of: osNumberOfMessageQs in PROJECT_FILE_NAME > framework > OSAbstracion > Interface > fsl_os_abstraction_config.h to a value > 0.  //fsl_os_abstraction_config.h #ifndef osNumberOfMutexes #define osNumberOfMutexes 5 #endif #ifndef osNumberOfMessageQs #define osNumberOfMessageQs 1 #endif #ifndef osNumberOfMessages #define osNumberOfMessages 10 #endif‍‍‍‍‍‍‍‍‍ //...‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍ Then, to start the task implementation it is needed to edit the file: PROJECT_FILE_NAME > framework > OSAbstracion > Source > fsl_os_abstraction_free_rtos.c.        First, we create the prototype of the main task function, then define the task using the “OSA_TASK_DEFINE” definition. The syntax should be the following: This function is part of the thread Management, it helps the user define the creation of a new thread, controlling the priority and stack requirements. The following parameters are used in the function definition. name: Should be the name of the function used as our task priority: The scheduler will grant a minor or major priority to our function with this parameter. instances: This parameter give us the control to limit the number of instances in order to manage the memory in the most optimal way. stackSz : This parameter has a default value, which is defined by the abstraction layer as: gMainThreadStackSize_c as 1024 bytes. useFloat : This parameter is part of the thread definition structure, is a Boolean, It defines if the thread will use floating point.   //fsl_os_abstraction_free_rtos.c /*! ********************************************************************************* ************************************************************************************* * Private functions ************************************************************************************* ********************************************************************************** */ OSA_TASK_DEFINE(startup_task, gMainThreadPriority_c, 1, gMainThreadStackSize_c, 0) ; void vfnTaskPWM(void* param); //New Task Definition OSA_TASK_DEFINE(vfnTaskPWM, 1, 1, 500, FALSE ); osaTaskId_t gAppTestTask1Id = 0; // TestTask1 Id osaTaskId_t pwmTask_queue = 0; //get defines from wireless_uart int main (void) { /* Initialize MCU clock */ hardware_init(); OSA_TaskCreate(OSA_TASK(startup_task), NULL); //Task and Queue creation. gAppTestTask1Id = OSA_TaskCreate(OSA_TASK(vfnTaskPWM), NULL); //Task Creation pwmTask_queue = OSA_MsgQCreate(1); //Scheduler starting vTaskStartScheduler(); return 0; } //..‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍   4. The function: OSA_TaskCreate returns a taskID it is required to create a osaTaskId_t variable as the following: osaTaskId_t gAppTestTask1Id = 0; and also another osaTaskId_t variable for the FreeRTOS queue we will be using : osaTaskId_t pwmTask_queue = 0.‍‍‍‍‍‍‍ 5. Inside the main function we will create our task in the same fashion the startup_task is created: gAppTestTask1Id = OSA_TaskCreate(OSA_TASK(vfnTaskPWM), NULL);‍‍‍‍‍‍‍ 6. We also need to create the queue using the same type of variable and using the OSA_MsgQCreate() function to create a new Queue: pwmTask_queue = OSA_MsgQCreate(1);‍‍‍‍‍‍‍ 7. After this statements the scheduler should start: vTaskStartScheduler(); 8. In the wireless_uart.c file it is required to add pwmTask_queue, created for the queue as an extern variable. //wireless_uart.c static uint8_t gAppSerMgrIf; static uint16_t mAppUartBufferSize = mAppUartBufferSize_c; static volatile bool_t mAppUartNewLine = FALSE; static volatile bool_t mAppDapaPending = FALSE; extern osaMsgQId_t pwmTask_queue; /************************************************************************************ ************************************************************************************* * Private functions prototypes ************************************************************************************* ************************************************************************************/ /* Gatt and Att callbacks */ static void BleApp_AdvertisingCallback(gapAdvertisingEvent_t *pAdvertisingEvent);‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍ Tasks and Queues implementation in our application code In this example we implemented the use of OSA_MsgQPut() to place the message received from the central peripheral in a queue by using: //wireles_uart.c static void BleApp_ReceivedUartStream(deviceId_t peerDeviceId, uint8_t *pStream, uint16_t streamLength) { static deviceId_t previousDeviceId = gInvalidDeviceId_c; char additionalInfoBuff[10] = { '\r', '\n', '[', '0', '0', '-', 'M', ']', ':', ' '}; uint8_t *pBuffer = NULL; uint32_t messageHeaderSize = 0; if (mAppUartNewLine || (previousDeviceId != peerDeviceId)) { streamLength += (uint32_t)sizeof(additionalInfoBuff); } /* Allocate buffer for asynchronous write */ pBuffer = MEM_BufferAlloc(streamLength); if (pBuffer != NULL) { /* if this is a message from a previous device, print device ID */ if (mAppUartNewLine || (previousDeviceId != peerDeviceId)) { messageHeaderSize = sizeof(additionalInfoBuff); if (mAppUartNewLine) { mAppUartNewLine = FALSE; } additionalInfoBuff[3] = '0' + (peerDeviceId / 10U); additionalInfoBuff[4] = '0' + (peerDeviceId % 10U); if (gGapCentral_c != maPeerInformation[peerDeviceId].gapRole) { additionalInfoBuff[6] = 'S'; } FLib_MemCpy(pBuffer, additionalInfoBuff, sizeof(additionalInfoBuff)); } FLib_MemCpy(pBuffer + messageHeaderSize, pStream, (uint32_t)streamLength - messageHeaderSize); /**** Adding a message into a Queue ****/ OSA_MsgQPut(pwmTask_queue, (void*)&pBuffer); /**************************************/ (void)Serial_AsyncWrite(gAppSerMgrIf, pBuffer, streamLength, Uart_TxCallBack, pBuffer); } /* update the previous device ID */ previousDeviceId = peerDeviceId; }‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍ This function points to the external queue variable created before the main() function of the project. Also points to the buffer pointer of the message received in BleApp_ReceivedUartStream(), These parameters can be accessed by using OSA_MsgQGet() function. osaStatus_t OSA_MsgQGet(osaMsgQId_t msgQId, void *pMessage, uint32_t millisec)‍‍ This function gets the message from the head of the message queue, the parameters of this function are the following: msgQId : Is the identifier of the queue function. pMessage : Is a pointer to the same message sent fromOSA_MsgQPut(); millisec : Is the number of milliseconds to wait for a message.   Inside the task created: vfnTaskPWM() there is an infinite while loop checking if a message is in the queue, this is accomplished by using the os_abstraction function: The rest of the task implementation is in a different C file. The external queue variable is defined in this file in addition to the task function prototype: /*pwmApplication.c*/ /*Global Variables*/ static uint8_t gAppSerMgrIf; extern osaMsgQId_t pwmTask_queue; /*Function Prototypes*/ void signalConfigValues(int red, int green, int blue); void getValuesRGB(uint8_t* msgString); int getInt(char *stringInteger, int size); /****Task Definition****/ void vfnTaskPWM(void* param); /* * Task to configure the PWM pins and start the timer * */ void vfnTaskPWM(void* param) { uint8_t* msgString; char msgString1[20] = { '\0', '\0', '\0', '\0','\0', '\0', '\0', '\0','\0', '\0', '\0', '\0','\0', '\0', '\0', '\0','\0', '\0', '\0', '\0'}; while(1) { /* * If there is a new message on queue the value will return a 0 according to the OSA_MsgQGet function * to compare the incoming message * */ while((OSA_MsgQGet(pwmTask_queue,(void*)&msgString,10)) == 0){ //shift-up the pointer value to get the payload message if(*msgString == '\r'){ while(*msgString != 32){ msgString++; } msgString++; } FLib_MemCpy(msgString1,msgString,20); if(FLib_MemCmp(msgString1, "OFF", 4)){ (void)Serial_Print(gAppSerMgrIf,"\n\r OFF: ", gAllowToBlock_d); //configure the PWM new function signalConfigValues(0,0,0) and StartTimers(CTMRA,CTMRB) signalConfigValues(0,0,0); } else{ //a function to convert values from a string to integers getValuesRGB(msgString); } } } } ‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍