Remember Processor Expert? Just to refresh your mind, is a development system to create, configure, optimize, migrate, and deliver software components that generate source code for Freescale silicon, supporting S08/RS08, S12(X), Coldfire, Coldfire+, Kinetis, DSC 56800/E, QorIQ and some other Power Architecture processors. And well, what's the such new great thing in it? Take a look: Microcontroller Driver Suite v10.0 is a software management system to perform Processor Expert's tasks and provide a low-cost, efficient solution for your designs. Just recently a great update has been made into it: the driver suite is delivered and installed as a comprehensive product with the Eclipse 3.7 (Indigo) IDE. It is also available as an Eclipse 3.7 plug-in. This extends Processor Expert software functionality to non-CodeWarrior IDE users for the supported platforms. The cool, useful part of all this is that Processor Expert technology packaged in the driver suite makes it much easier to optimize the low-level intricacies of a hardware platform. It also eliminates the necessity for one-size-fits-all drivers, therefore the driver suite allows you to design custom peripheral drivers ideally suited to your needs, without the need for extensive hardware knowledge! And just as aesy as that, you get a whole new set of possibilities to empower your design! You can try the software by just clicking here Microcontrollers Driver Suite v10.0 And you can also get the Driver Suite for Eclipse by clicking on here Microcontroller Driver Suite v10.0, for Eclipse 3.7 (Indigo)

The new NXP Pins Tool for i.MX Applications Processors which has been showcased at FTF 2016 in Austin is now available as desktop application: The Pins Tool makes configuring, muxing and routing of pins very easy and fast. It provides real-time feedback of conflicts and provides an intuitive graphical interface with several views. The tool generates device tree (.dtsi) and sources files which can be directly integrated into C/C++ applications. The following devices are supported: - i.MX 6Dual/Quad - i.MX 6DualPlus/QuadPlus - i.MX 6DualLite - i.MX 6Solo - i.MX 6SoloLite - i.MX 6SoloX - i.MX 6UltraLite - i.MX 7Dual - i.MX 7Solo The Pins Tool is available as download from http://www.nxp.com/pinsimx (Windows, Mac OS X and Linux 64bit) under the 'Software' category. There are two different installer types: 'offline' is a 140 MByte download. This method is recommended for slower internet connections or for installation on multiple machines. 'online' is a smaller download, all the other installation data will be loaded from the internet during installation. Mac OS X and Linux installers are 64bit. For Windows there are both 32bit and 64bit installers available. It is recommended to download the additional header files if not already installed/provided by your BSP because they are referenced by the initialization code. The header files are available in the following download under 'Headers': Documentation is available under the documentation section, as well attached to this article: For installation, check out the installation guide. For first steps, use the Getting started document. We hope you find this tool useful! i.MX Community | NXP Community: http://www.imxcommunity.org

Introduction The goal of this example is to read all ADC inputs of Kinetis KL25 in a row without the need of using CPU core for switching channels and pins and reading individual values. The FRDM-KL25 board features Kinetis MKL25Z128VLK4 microcontroller. This MCU contains a 16-bit AD converter with 16 inputs. In Processor Expert there is available ADC_LDD component which can be used for measuring values on these pins. However, there is a limitation that some of the input pins (e.g. ADC0_SE4a and ADC0_SE4b) are muxed to same channel and ADC_LDD doesn’t allow to measure such two pins at once without additional mux-switching code. The MCU also does not provide an option of scanning through the ADC channels and the channels need to be switched by the user. To resolve the goal of measuring all inputs in a row the Peripheral Initialization components and DMA (Direct Memory Access) peripheral can be used. Project Description Note: The archive with the example project is attached to this article. The DMA in this example is used for controlling all the channel switching, pin mux selection and reading the results for series of measurement into a memory buffer. Results are written to serial console (virtual serial port) provided by the FRDM board. The Direct Memory Access (DMA) channels are configured for writing and reading ADC registers the following way: DMA channel 0 reads converted results (ADC0_RA register) DMA channel 1 changes the ADC pin group selection multiplexer (ADC0_CFG2 register) using values from memory array ChannelsCfg DMA channel 2 selects the ADC channel and starts conversion (ADC0_SC1A register) using values from memory array ChannelsCfg2 The data for the DMA channel 1 a 2 are prepared in the ChannelsCfg and ChannelsCfg2 arrays prepared in memory and the DMA operates in the following cycle: In the beginning, the DMA channel 1 transfer is started using software trigger. This selects the pin (a/b). Then, DMA channel 2 is immediately executed because of enabled DMA channel linking. This configures the channel and starts the conversion. After the conversion is complete, the result is read by DMA channel 0 and stored to results array. Channel linking executes the Channel 1 transfer and the cycle continues. After all needed channels are measured (DMA byte counter reaches 0), the DMA Interrupt is invoked so the user code is notified. See the following figure describing the process: Component Configuration The application uses generated driver modules from the following Processor Expert components: ConsoleIO properties setup This component redirects printf command output to FRDM USB virtual serial port which is connected to UART0 pins PTA1/UART0_RX and PTA2/UART0_TX. The serial device, speed and pins are configured in inherited Serial_LDD component. Init_ADC properties setup The Init_ADC provides ADC initialization code with all channels enabled and set to single-ended. The clock can be selected according to any valid value, according to the user needs.The same with HW average settings. Compare functionality will not be used in this demo.           Pins configuration - all pins available on the board are enabled:           Interrupts,  DMA and Triggering - Interrupts are disabled, DMA request is enabled. Triggering is disabled, as it’s not used in this demo project, However, the application could be extended to use it.           Init_DMA properties setup The Init_DMA provides provides initialization code for the DMA. Clock gate and DMA multiplexor are enabled:           DMA Channel 0 16-bit results are transferred from ADC0_RA register (see proprerty Data source / Address). Transfer mode is Cycle-steal, which means that only one transaction is done per each external request. The destination address initial value is not filled in the inspector because it's filled repeatedly in the application code. Channel linking is set to trigger channel 1 after each transfer DMA mux settings for the Channel 0 are enabled and ADC0_DMA_Request is selected, which is the signal from ADC when the conversion ends. "DMA transfer done" interrupt for this channel is enabled. The ADCint ISR function will be called. External request (request from ADC) is Enabled to start the transfer. Byte count will also be changed before every sequence Property values:                     DMA Channel 1 DMA channel 1 changes the ADC pin group selection multiplexer (ADC0_CFG2 register) using values from memory array ChannelsCfg. Please note that the source address initial value is not filled, will be set in the application code along with the Byte count value. There is no HW trigger for this channel, it's set to be triggered by SW only (and by linking mechanism, which will be used). The linking from this channel is set to trigger CH2 after the transfer. No interrupt is enabled for this channel                DMA Channel 2 DMA channel 2 selects the ADC channel and starts conversion (ADC0_SC1A register) using values from memory array ChannelsCfg2. No channel is linked after the transfer ends - No link. No external channel request is selected, this channel transfer is triggered by linking from CH2.                TimerUnit_LDD It's used in the application code to provide delay to slow down console output. The TPM0 counter is used with the period of approx. 350ms. No interurpt is used. Auto initialization is enabled.                Code The channels/pins to be measured are specified in the ChannelsCfg and ChannelsCfg2 arrays. These arrays contains a list of pins to be measured, the order can be changed according to the user needs, the channels can even be measured multiple times. The special value 0x1F stops the conversion. // configuration array for channels - channel numbers. Should ends with 0x1F which stops conversion // seconcd onfiguration array coreesponding to channels selecting A/B pins // For example: 0 + PIN_A corresponds to the pin ADC0_SE0,   5 + PIN_5 selects the pin ADC0_SE5b // You can use these arrays to reorder the measurement as you need const uint8_t ChannelsCfg [ADC_CHANNELS_COUNT + 1] =  { 0,     4,     3,     7,     4,    23,    8,     9,    11,     12,    13,    14,    15,    5,     6,     7,     0x1F }; const uint8_t ChannelsCfg2[ADC_CHANNELS_COUNT + 1] =  {PIN_A, PIN_A, PIN_A, PIN_A, PIN_B, PIN_A, PIN_A, PIN_A, PIN_A, PIN_A, PIN_A, PIN_A, PIN_A, PIN_B, PIN_B, PIN_B,    0 }; In the main loop, the application first re-initializes the DMA values and strarts the sequence by software triggerring the DMA channel 1. // loop while (TRUE) {    // clear flag     Measured = FALSE;    // reset DMA0 destination pointer to beginning of the buffer    DMA_DAR0 = (uint32_t) &MeasuredValues;    // reset DMA1 source pointer (MUX switching writes)    DMA_SAR1 = (uint32_t) &ChannelsCfg2;    // reset DMA2 source pointer (channel switching and conversion start writes)    DMA_SAR2 = (uint32_t) &ChannelsCfg;    // number of total bytes to be transfered from the ADC result register A    DMA_DSR_BCR0 = ADC_CHANNELS_COUNT * 2;    // set number of total bytes to be transfered to the ADC0_CFG2    DMA_DSR_BCR1 = ADC_CHANNELS_COUNT + 1;    // set number of total bytes to be transfered to the ADC0_SC1A.     DMA_DSR_BCR2 = ADC_CHANNELS_COUNT + 1;    // start first DMA1 transfer (selects mux, then fires channel 2 to select channel which starts the conversion)    DMA_DCR1 |= DMA_DCR_START_MASK;    // wait till it's all measured   while (!Measured) {}    // print all measured values to console   for (i=0; i<ADC_CHANNELS_COUNT; i++) {     printf ("%7u", (uint16_t) MeasuredValues[i]);   }      printf ("\n");    // reset the counter   TU1_ResetCounter(TU1_DeviceData);   // wait for some time to slow down output   while (TU1_GetCounterValue(TU1_DeviceData) < 50000) {} } Running the project The project can be run usual way. import the project into CodeWarrior for MCUs V10.5. Build the project Connect the FRDM-KL25 board Start debuging and run the code Run terminal application or use the Terminal view in eclpise. Set it to use the virtual serial port created for the board. The parameters should be set to 38400,no parity, 8 bits ,1 stopbit.

SD_Card Description SD Card low level driver Component SD_Card.PEupd Dependencies FreeRTOS, Wait, Timeout License License : Open Source (LGPL) Copyright : (c) Copyright Erich Styger, 2012, all rights reserved. This an open source software implementing an SD card low level driver useful for the the ChaN FatFS, using Processor Expert. This is a free software and is opened for education, research and commercial developments under license policy of following terms: * This is a free software and there is NO WARRANTY. * No restriction on use. You can use, modify and redistribute it for personal, non-profit or commercial product UNDER YOUR RESPONSIBILITY. * Redistributions of source code must retain the above copyright notice.

This document describes the creation of the Processor Expert LwIP demo application in KDS 3.0.0  (Processor Expert with KSDK 1.2.0) that allows communication via UDP/IP protocol within local network. There is also used DHCP protocol for leasing of the IP address in the local network (DHCP server must be available). This demo application demonstrates how to communicate with a user application on the target board via Ethernet. This demo project can be used a starting point for user’s application. The demo application provides the following functionality: LwIP stack initialization including the DHCP (DHCP is started to lease the IP address). The UDP is initialized and bind to port number 7 (receiving of broadcast is enabled) When a UDP packet is received the content is processed (a command is executed): There are supported following commands: LED GREEN ON – switch the green led on (the RGB led) on the FRDM-K64F board LED GREEN OFF – switch the green led off (the RGB led) on the FRDM-K64F board LED BLUE ON – switch the blue led on (the RGB led) on the FRDM-K64F board LED BLUE OFF – switch the blue led off (the RGB led) on the FRDM-K64F board LED RED ON – switch the red led on (the RGB led) on the FRDM-K64F board LED RED OFF – switch the red led off (the RGB led) on the FRDM-K64F board K64FIPRQ – send the IP address that is leased by DHCP in the message “IP addr: N.N.N.N” EXIT – exit the demo and stop the DHCP The debug logs are enabled and accessible by using a serial terminal (UART, baudrate 115200, data 8 bits, one stop bit, no flow control). Preparation First of all the KDS 3.0.0 and KSDK 1.2.0 must be installed. You can find instructions in the document Kinetis Design Studio Videos, Part 1: Installation of KDS and Kinetis SDK. LwIP stack 1.3.0 introduction LwIP is a small independent implementation of the TCP/IP protocol suite that has been developed by Adam Dunkels at the Computer and Networks Architectures (CNA) lab at the Swedish Institute of Computer Science (SICS). The focus of the LwIP TCP/IP implementation is to reduce resource usage while still having a full scale TCP. This making LwIP suitable for use in embedded systems with tens of kilobytes of free RAM and room for around 40-100 kilobytes of code ROM. LwIP features:     IP (Internet Protocol) including packet forwarding over multiple network interfaces     ICMP (Internet Control Message Protocol) for network maintenance and debugging     IGMP (Internet Group Management Protocol) for multicast traffic management     UDP (User Datagram Protocol) including experimental UDP-lite extensions     TCP (Transmission Control Protocol) with congestion control, RTT estimation and fast recovery/fast retransmit     raw/native API for enhanced performance     Optional Berkeley-like socket API     DNS (Domain names resolver)     SNMP (Simple Network Management Protocol)     DHCP (Dynamic Host Configuration Protocol)     AUTOIP (for IPv4, conform with RFC 3927)     PPP (Point-to-Point Protocol)     ARP (Address Resolution Protocol) for Ethernet The UDP packets are processed through the LwIP by the following way: You can find LwIP documentation on webpage http://www.nongnu.org/lwip/ or LwIP wiki pages http://lwip.wikia.com/wiki/LwIP_Wiki. New project The project is created in the KDS 3.0.0 by the following way: New Kinetis project (KSDK 1.2.0 and Processor Expert selected) for the FRDM-K64F target board is created. Clock configuration: System Oscillator 0 – external oscillator 50MHz New Clock configuration 6 – PEE, Core Clock 100Mhz, Bus Clock 50 MHz, External Bus Clock 25Mhz, Flash clock 25MHz LwIP library (stack) is linked to the project fsl_phy_driver.c/h driver is added into the project (from MQX RTCS) fsl_enet component added into the PEx project fsl_debug_console component added into the PEx project. It provides debug output and it is configured by the following way: fsl_hwtimer component added into the PEx project. It is configured for PIT timer to provide LwIP timing functionality. It is configured by the following way: fsl_gpio_hal component added into the PEx project to provide GPIO access for pins driving RGB LED on the FRDM_K64F board. The whole project contains following libraries, drivers and components: For  compilation and linking of the project are necessary also following LwIP library paths: "${PROJECT_KSDK_PATH}\middleware\tcpip\lwip" "${PROJECT_KSDK_PATH}\middleware\tcpip\lwip\port" "${PROJECT_KSDK_PATH}\middleware\tcpip\lwip\port\arch" "${PROJECT_KSDK_PATH}\middleware\tcpip\lwip\src" "${PROJECT_KSDK_PATH}\middleware\tcpip\lwip\src\include" "${PROJECT_KSDK_PATH}\middleware\tcpip\lwip\src\include\ipv4" "${PROJECT_KSDK_PATH}\middleware\tcpip\lwip\src\include\ipv4\lwip" "${PROJECT_KSDK_PATH}\middleware\tcpip\lwip\src\include\ipv6" "${PROJECT_KSDK_PATH}\middleware\tcpip\lwip\src\include\ipv6\lwip" "${PROJECT_KSDK_PATH}\middleware\tcpip\lwip\src\include\lwip" "${PROJECT_KSDK_PATH}\middleware\tcpip\lwip\src\include\netif" "${PROJECT_KSDK_PATH}\middleware\tcpip\lwip\src\include\posix" "${PROJECT_KSDK_PATH}\middleware\tcpip\lwip\src\include" This project can be built and can be used for the LwIP demo application design. Note: This application has been created by using KSDK UDP echo demo project source code. The UDP K64F app demo application code The UDP K64F app demo project contains the following initialization code for UDP and DHCP: /* initialization of LwIP stack */ /* Perform Sanity check of user-configurable values, and initialize all modules. */ lwip_init(); /* default IP addresses - DHCP is used */ IP4_ADDR(&fsl_netif0_ipaddr, 0,0,0,0); IP4_ADDR(&fsl_netif0_netmask, 0,0,0,0); IP4_ADDR(&fsl_netif0_gw, 0,0,0,0); /* Add a network interface to the list of lwIP netifs. */ netif_add(&fsl_netif0, &fsl_netif0_ipaddr, &fsl_netif0_netmask, &fsl_netif0_gw, NULL, ethernetif_init, ethernet_input); /* Set the network interface as the default network interface. */ netif_set_default(&fsl_netif0); /* obtain the IP address, default gateway and subnet mask by using DHCP*/ if (dhcp_start(&fsl_netif0) != ERR_OK) {          LWIP_DEBUGF(LWIP_DBG_ON, ("DHCP failed")); } /* initialize UDP on the port 7 */ udp_demo_init(); The udp_demo_init() initialize the pcb (protocol control block), bind the pcb to the port number 7 and set the callback function for receiving of UDP packets. The demo application can be closed by using the exit command. When the command is executed the UDP is disconnected (unbound) and DHPC is stopped (leased IP address is released). The following code is executed: /* UDP disconnect */ udp_demo_deinit(); /* finish the lease of the IP address */ dhcp_release(&fsl_netif0); Please note, that the exit command does not cause the restart of the demo application. The application finish in a infinite loop and it does not reply on any command that is send by using UDP packet. The reset is necessary for restarting of this application. The udp_echo_recv() callback function is used for receiving of UDP packets. This function process received data and execution of the following commands: LED GREEN ON – switch the green led on (the RGB led) on the FRDM-K64F board LED GREEN OFF – switch the green led off (the RGB led) on the FRDM-K64F board LED BLUE ON – switch the blue led on (the RGB led) on the FRDM-K64F board LED BLUE OFF – switch the blue led off (the RGB led) on the FRDM-K64F board LED RED ON – switch the red led on (the RGB led) on the FRDM-K64F board LED RED OFF – switch the red led off (the RGB led) on the FRDM-K64F board K64FIPRQ – send the IP address that is leased by DHCP in the message “IP addr: N.N.N.N” EXIT – exit the demo and stop the DHCP Note: The K64FIPRQ (K64F IP Request) command can be used for finding of this device in a local network. When a packet with this command is broadcasted the demo application sends the response “IP addr: N.N.N.N” and the device can communicate with demo application by using the leased IP address. See also the chapter Client demo application. Configuration of LwIP The default configuration of LwIP stack is available in the header file /UDP K64F app/lwip/src/include/lwip/opt.h. The UDP K64F demo application configuration parameters are available in the header file /UDP K64F app/lwip/port/lwipopts.h. There is enabled debug output (the fsl_debug_console is used) and also detailed debug for NETIF, UDP and DHCP, see the following part of the options in the lwipopts.h header file: /* ------------------------------------ ---------- Debugging options ---------- ------------------------------------ */ #define LWIP_DEBUG . . . /* detailed debug info for DHCP, UDP and NETIF */ #define NETIF_DEBUG                     LWIP_DBG_ON #define UDP_DEBUG                       LWIP_DBG_ON #define DHCP_DEBUG                      LWIP_DBG_ON If you need not this debug output you can undefined the LWIP_DEBUG symbol and/or define the detailed debug info symbols as: /* detailed debug info for DHCP, UDP and NETIF */ #define NETIF_DEBUG                     LWIP_DBG_OFF #define UDP_DEBUG                       LWIP_DBG_OFF #define DHCP_DEBUG                      LWIP_DBG_OFF The disabling of the debug output has also impact on the code size. The default configuration with debug output has the following code size: 'Invoking: Cross ARM GNU Print Size' arm-none-eabi-size --format=berkeley "UDP K64F app.elf" text         data          bss          dec          hex      filename 95308 180        75300 170788        29b24      UDP K64F app.elf 'Finished building: UDP K64F app.siz' Teh code size without debug output is following: arm-none-eabi-size --format=berkeley "UDP K64F app.elf" text         data          bss          dec          hex      filename 83024 180        75252 158456        26af8      UDP K64F app.elf 'Finished building: UDP K64F app.siz' Client demo application The UDP client application can be created by using Eclipse Java EE IDE. I have implemented a simple client terminal application the support UDP K64F demo application commands. This terminal application use the subnet mask and host IP address to create a broadcast IP address and send the K64FIPRQ message (command) in the UDP packet. If the FRDM-K64F target board with the demo application is connect to the local network the device send the response with IP address back to the UDP Client application. The received IP address is used for further communication by this application. When you select a command (write number and press the Enter in the terminal window) the selected command is sent and response text displayed. Note: You can run the application by using the Test UDP Client\Executable\TestClient_FRDM-K64F_demo.jar file or you can run the batch file Test UDP Client\Executable\TestClient_FRDM-K64F_demo.bat. Conclusion The LwIP stack library can be used as a static library in a Processor Expert project with embedded components (device drivers) that provides required functionality for the stack (physical layer of TCP/IP, timing and debug output). The Processor Expert allows using embedded components for rapid application development by using KSDK and therefore the demo application can be also used a starting point for customers' projects based on the K64 derivatives.

Product Information on Freescale.com Product Summary Page Documentation Downloads Training Frequently Asked Questions (FAQ) Where can I find Processor Expert examples and tutorials in Driver Suite? How to configure the processor component to match my hardware? Adding Processor Expert to C Project (without SDK in PEx Driver Suite) Adding Processor Expert to C Project (with SDK in PEx Driver Suite) Application Notes AN4819 - Building a Project using IAR Eclipse Plugin - This application note provides steps to configure IAR Eclipse plugin and using Processor Expert (PEx) together with IAR build tool chain. AN4913  - Building and Debugging a project using Keil MDK-ARM Eclipse plug-in - This application note provides steps to configure Keil MDK-ARM Eclipse plug-in and using Processor Expert together with Keil build tool chain. Other Resources Processor Expert Tools in Microcontroller Driver Suite - Training Videos

The Processor Expert Software Wiki provides useful “how to” and FAQ information not available on Freescale websites or  forums.  The links below provide useful design resources for Processor Expert product designers and users. Software Suites Component Exchange Integrated with CodeWarrior Tools Microcontroller Driver Suite QorIQ Configuration Suite QorIQ Optimization Suite Component Development Environment Freescale Components (buy now) Community Components (freeware) Frequently Asked Questions (FAQ) Processor Expert Software Suites FAQs (coming soon) QorIQ Configuration Suite (coming soon) Component Development Environment FAQs (coming soon) Components Exchange FAQs (coming soon)

Importing Example Projects Select File > Import from CodeWarrior menu. The Import dialog appears. Select General / Existing Projects into Workspace and click Next. Select the Select root directory option and click Browse. Browse to the following location of CodeWarrior installation directory: <CWInstallDir>\MCU\CodeWarrior_Examples\Processor_Expert Select the folder containing the example projects if you want to import multiple projects, or the specific example project. Click OK. If you have selected the folder, the list of the example projects available in the folder appears in the Projects area. Check the checkbox adjacent to the project(s) you want to import. Select the Copy projects into workspace checkbox to create an independent copy of the project into the workspace. Click Finish. Tutorials and Tips Tutorials and tips are provided in a form of cheat-sheets. To access them, use the CodeWarrior menu Help > Cheat sheets… and select the CodeWarrior Processor Expert Features. Typical Component Usage Examples of using generated code can be found on Typical usage page of the components. This page is provided within a component help. To get this help use the component’s pop-up menu command Help on component or browse the component in the Processor Expert Components Manual within the CodeWarrior help system at CodeWarrior for Microcontrollers V10.x > Processor Expert Manuals. The Typical usage page is available as a part of documentation for every LDD or high level component.

The C project that doesn't use Processor Expert can be converted to Processor Expert. This is useful when the user finds out that he/she would like to use additional features of Processor Expert. WARNING! Note that in most cases this conversion involves necessary manual changes in the application code, because for example the register interrupt vectors table definitions created by the user often conflicts with Processor Expert definitions. Don't forget to backup the whole project before the conversion. Some files will have to be removed from the project. The conversion to Processor Expert is recommended to experienced users only. Steps: Select the command in the main menu File > New > Other and in the New Project Wizard select Processor Expert / Enable Processor Expert for Existing C Project Select the project you want to update. Select the derivative that will be included in PEx project (you should use the same derivative that has been selected when the project was created without PEx). Select the target compiler (select the GNU C Compiler by default if you have not installed any other compiler in the Kinetis Design Studio) Confirm changes (renaming of main.c module and any other changes you want to apply) and click on the Finish button. The project with PEx is created but there need to be done following changes: Remove the duplicate main.c module – the main_backup.c file (copy content of the old main.c module into the new one created by PEx) and delete the old version of the file (main_backup.c) Remove all IO maps files from the original project. The KDS bareboard project have all these files included in the Includes folder by default (core_......h files and IO map files). Remove all startup files from the original project. The KDS bareboard project have all these files (startup_xxxxxx.S and system_xxxxxx.c files) included in the Project_Settings/Startup_Code folder. Remove linker file xxxxxxxxxxxx_flash.ld from the original project. Use the Processor Expert.ld linker file that is generated by Processor Expert. In the context menu of the project select Properties and in the Properties window go the C/C++ Build > Settings > Tool Settings, select the Cross ARM C++ Linker / General and select the ProcessorExpert.ld file instead of MK......_flash.ld (see the following screenshot).

Learn the Processor Expert UI, what components are, and how to add one to a project.

Processor Expert provides possibility to switch between processor modes by providing concept of “operation modes”. The CPU component provides a function SetOperationMode that can be called to select one the following general modes: RUN – normal mode, running at full speed. WAIT – core sleeps, but the peripherals are running SLEEP – both core and peripherals sleep and can wake up to continue execution STOP – both core and peripherals sleep and usually can wake up only via reset These modes are mapped to the platform specific modes of the chip. By switching to WAIT/SLEEP/STOP modes when possible (for example no computation is done for a while),  it's possible to achieve a lower consumption of the whole chip. The following table shows an example of the operation modes mapping for Kinetis L that shows the state of the core, bus and recovery method for each mode:   The Very low power mode option is available in Clock configurations of CPU properties (see below), i.e. the selection of the power mode is done by combination of the SetOperationMode and SetClockConfiguration methods. The exact mapping of the DOM_xxx options can be configured in the CPU component inspector (the Advenced view has be enabled). For example the DOM_SLEEP can be mapped to normal stop mode, very low power stop, partial stop 1 or partial stop 2 of Kinetis L.

This document describes the creation of the following low power demo application: When the application starts the green LED blink one time, The RTC device  alarm is set to 15 second  (external oscillator 32768Hz is used) to wakeup CPU and the CPU enters the VLLS1 mode (VLLS0 mode cannot be used with external oscillator).  The CPU wake up is possible by the following ways: - When you push the SW2 button the processor is woken up and the green LED start blinking (5 times). - When you short the pin PTB6 to ground 5 times (the pin is available on the 8 pin header connector – pin number 4; you can for example connect a button to the pin number 4 and ground) the processor is woken and the green LED start blinking (5 times). - When selected RTC timeout expired (15 seconds) the processor is woken by the alarm interrupt and the green LED start blinking (5 times). The application is initialized again and recovery from the VLLS1 mode is executed. The alarm is set to 15 second and the CPU enters the VLLS1 mode again. Preparation First of all the KDS 1.1.1 (KDS 2.0.0) and KSDK 1.0.0 for KL03Z must be installed. You can find instructions in the document How to install KL03 SDK support in KDS 1.1.1 and KDS 2.0.0. New project When you properly install and update all the software you are prepared to create the Low power demo application. Create a new Kinetis design Studio project: Select the FRDM-KL03Z board Select the Kinetis SDK path to the KSDK 1.0.0 for KL03Z and select Processor Expert The application is created but there are many warnings reported in the Problems window saying that there is a conflict: Ignored error: Selected value is in conflict with other configuration(s) property 'Pin 13', property 'CH1 - Channel 1', property 'Pin' from component gpio_pins, property 'ERCLK32K clock output' Exclusive connection required by property 'CH1 - Channel 1'; Selected value is in conflict with other configuration property 'CH1 - Channel 1', conflict in configuration of MUX bit-field of PORTB_PCR13 register. ; Selected value is in conflict with other configuration property 'Pin 13', property 'Pin' from component gpio_pins, conflict in configuration of MUX bit-field of PORTB_PCR13 register. (CLKOUT - Oscillator output), Low power demo KL03, .... To resolve all these warnings you need to select the required functionality of reported pins in the PinSettings component: Open the Component Inspector of the PinSettings component, select the Routing tab and select the Pins View mode. All pins are available on one tab and you see small exclamation icons in rows where are reported conflicts: Click on each item with warning icon (the Selected Function row) and uncheck unused function of the pin to select one function only, i.e. you need to specify which functionality of the pin is initialized by code generated by Processor Expert. You can select GPIO functionality in all case except the last pin number 24 that is used by debugger as swd_dio pin: You can see that there is not any warning now and all pins are routed according to the selection you have done. There is also necessary to change the linker settings when you have installed the new version of GCC tools (according to the document that is available in the KSDK 1.0.0 for KL03Z installation folder in KSDK_1.0.0-KL03Z\doc\Kinetis SDK Freescale Freedom FRDM-KL03Z Platform User’s Guide.pdf – chapter Appendix B: Kinetis Design Studio environment variable fix and swap tool chain) Open the context menu of the project, select Properties item and change the Other linker flags settings to “-specs=nano.specs -specs=nosys.specs”, in C/C++ Build / Settings,  Tools Settigns tab, Cross ARM C++ Linker/Miscellaneous: Tip If you want to know details of compiled code and the code size, you can use the following options to create extended list file and print code size info on the following Toolchains tab: You can generate Processor Expert code and process Build of the application without any error and warning. When the Build is finished the following information is provided in the Console window: 'Invoking: Cross ARM GNU Create Listing' arm-none-eabi-objdump --source --all-headers --demangle --line-numbers --wide "Low power demo KL03.elf" > "Low power demo KL03.lst" 'Finished building: Low power demo KL03.lst' ' ' 'Invoking: Cross ARM GNU Print Size' arm-none-eabi-size --format=berkeley "Low power demo KL03.elf"    text          data           bss           dec           hex       filename    8860           112           640          9612          258c       Low power demo KL03.elf 'Finished building: Low power demo KL03.siz' Routing of pins When you open the gpio_pins component (in Component Inspector window) you can see that there are configured pins that are already used on target board: SW2 - ADC0_SE9/PTB0/IRQ_5/LLWU_P4/EXTRG_IN/SPI0_SCK/I2C0_SCL – input pin for the SW2 button on the board SW3 - ADC0_SE1/CMP0_IN1/PTB5/IRQ_12/TPM1_CH1/NMI_b - input pin for the SW3 button on the board ACCEL_INT - ADC0_SE0/CMP0_IN0/PTA12/IRQ_13/LPTMR0_ALT2/TPM1_CH0/TPM_CLKIN0/CLKOUT – input pin of inertial sensor interrupt LED_RED - PTB10/TPM0_CH1/SPI0_SS_b – output pin that driver the red LED of the RGB LED on the board LED_GREEN - PTB11/TPM0_CH0/SPI0_MISO - output pin that driver the green LED of the RGB LED on the board LED_BLUE - PTB13/CLKOUT32K/TPM1_CH1/RTC_CLKOUT - output pin that driver the blue LED of the RGB LED on the board Note: You can see routing of all pins when you generate report of PinSettings component. Open the Component Inspector of PinSettins, Routing tab and click on the HTML Report button. We will use the SW2 button to wakeup the CPU and the green LED for indication of the CPU state. Adding Processor Expert components Now you can add all components for the low power demo application. Init_LLWU and fsl_llwu_hal components to control LLWU device Init_SRTC and fsl_rtc_hal to control RTC device Init_LPTMR and fsl_lptmr_hal to control LPTMR device fsl_smc_hal to control SMC (System Mode Controller) device CPU device We are going to use external oscillator 32768Hz and we need to configure device to allow Very Low Leakage Stop modes. There are set following properties in the Component Inspector of the CPU (switch to Advance view): Check that the Clock settings/Clock Sources/System oscillator 0 property is Enabled and set Enable in stop property to Enabled. The Clock source, clock pins and clock frequency are preset for the FRDM-KL03Z board. Go to the Clock configuration/Clock Configuration 0 and set: Internal reference clock/Slow IRC frequency to 2MHz (it is enough for our demo application and it also decreases power consumption). MCG lite settings/MCG mode set to LIRC_2M Very low power mode to Enabled (leave setting of VLP mode entry to User because the VLLS1 mode is entered after blinking; we will write the code to enter VLLS1 mode) System clocks/Core clock set to 0.5Mhz System clocks/Bus clock set to 0.5Mhz (it allow us to enter very low leakage stop modes) Set Low Power mode settings/Acknowledge isolation to Not allowed value (we will do it in the user code) LLWU (Low-Leakage Wakeup unit) device Open the Component Inspector of Init_LLWU, switch to Advance view and set following properties: Set Settings/External Source/Pin 4 to Any edge value (we will use this pin that is connected to SW2 button) Set Pins/Pin 4 to Enabled and select SW2 in the item below Set Initialization/Utilize after reset values to no We will use the LLWU to wake-up the CPU and we need not any interrupt. RTC (Real Time Clock) device Open the Component Inspector of Init_SRTC, switch to Advance view and set following properties: Set Settings/Clock gate to Enabled Set Settings/Oscillator settings/Oscillator state to Enabled (it enables external oscillator also in stop modes) Set Settings/Time settins/Alarm time [s] to 15 (15 seconds timeout to wake-up from VLLS1 mode) Set Interrupts/ RTC interrupt/Interrupt request to Enabled Set Interrupts/ RTC interrupt/Time overflow interrupt to Disabled Set Interrupts/ RTC interrupt/Time invalid interrupt to Disabled Set Initialization/Time counter to Enabled Set Initialization/Utilize after reset values to no LPTMR (Low-Power Timer) device Open the Component Inspector of Init_LPTMR, switch to Advance view and set following properties: Set  Settings/Clock gate to Enabled Set Settings/Clock settings/Clock select to Internal 1kHz LPO (this clock source is enabled in the VLLS1 mode) Set Settings/Clock settings/Prescale value/Glitch filter to Prescaler/64; Glitch Filter 32 (it will eliminates glitches on connected button that will be used for generating pulses) Set Settings/Compare value to 4 (the LPTMR interrupt is invoked when the compare value is equal to counter and the counter value is increased, i.e. 5 pulses on the input pins invoke the LPTMR interrupt) Set Settings/Timer mode to Pulse Counter (we will use the timer to count external pulses on the input pin 3) Set Settings/Pin select to Input 3 Set Settings/Pin polarity to Active Low Set Pins/Input pin 3 to Enabled and select PTB6/IRQ_2/LPTMR0_ALT3/TPM1_CH1, TPM_CLKIN1 in Pin 3 item. Set Interrupts/Interrupt request to Enabled Set Interrupts/Timer interrupt to Enabled (we will use the timer interrupt to wake-up CPU from VLLS1 mode after 5 pulses on the input 3 pin) Set Initialization/Timer enable to yes Set Initialization/Utilize after reset values to no To avoid glitches on the PTB6 pin, that is used as input pin of the LPTMR, we will also enable pull-up in the PinSettins. Open Component Inspector of the PinSettings, select Functional Properties tab and set the pin number 1 (PTB6) as follows: We have finished design time settings of Processor Expert components and we are ready to write the application code. When you generate code and Build the application there will not be any error or warning. The Processor Expert project looks as follow: Application  code During the component settings we have enabled two interrupts – RTC interrupt and LPTMR interrupt. Therefore we need to write theses interrupt service routines. If you look for example into RTC.h file, you can find the declaration of the RTC_IRQHandler interrupt routine. So we can use the declaration to write the definition of the routine in the main.c program module: #define RTC_ALARM_TIMEOUT_SEC 15 #define LED_BLINK 5 /* RTC interrupt service routine */ PE_ISR(RTC_IRQHandler) { if (RTC_HAL_HasAlarmOccured(RTC_BASE)) { // set the next alarm in RTC_ALARM_TIMEOUT_SEC seconds (clear also the TAF flag) RTC_HAL_SetAlarmReg(RTC_BASE,RTC_HAL_GetAlarmReg(RTC_BASE) + RTC_ALARM_TIMEOUT_SEC); } if (RTC_HAL_IsTimeInvalid(RTC_BASE)) {        /* clear TIF (Time Invalid Flag) by stop of the counter and setting TSR reg */        RTC_HAL_EnableCounter(RTC_BASE, false);        RTC_HAL_SetSecsReg(RTC_BASE, 0);        /* enable counter */        RTC_HAL_EnableCounter(RTC_BASE, true); } } This interrupt routine services the Alarm interrupt in case that it is invoked during blinking of the green LED in the run mode (clear the flag and set the new Alarm time) and also it services the Invalid Time interrupt that can occur during recovering from the VLLS1 mode. Please note, that RTC module is little bit special, it runs in all run, wait and stop modes and the reset enables the Time Invalid interrupt bit (TIIE bit in RTC_IER) and invoke the Time Invalid interrupt on reset (POR or software reset). Therefore we need to clear the Invalid Time flag otherwise the application remain invoking RTC interrupt in an infinite cycle and the application does not work at all (it is also one of the issue that has not a straight forward solution). The RTC interrupt routine (defined above) shall properly serve all case we need in our application. Please note, that RTC interrupt always cause the wake-up from low-leakage stops modes (it is not configurable by LLWU on KL03 derivatives – see the chip-specific LLWU information). In addition, the after reset value of RTC_SR register is 0x01 (TIF flag is set). Therefore when the RTC is not initialized and a low-leakage stop mode is entered the CPU is immediately woken-up due to the RTC module interrupt flag (TIF flag is set). I.e. you must always properly initialize RTC module and clear all flags before you enter a low-leakage stop mode. We need also a service routine for the LPTMR device that is used for waking up from VLSS1 mode. This is a simple interrupt service routine that just clear the LPTMR interrupt flag: /* LPTMR interrupt service routine */ PE_ISR(LPTMR0_IRQHandler) { /* clear LPTMR interrupt flag */ LPTMR_HAL_ClearIntFlag(LPTMR0_BASE); } Now we can write the main() function. We will need a temporary count variables for blinking: /* Write your local variable definition here */ volatile uint32_t i; // for waiting uint8_t blink_count; After devices initialization in PE_low_level_init() we need to check the reason of reset (POR reset or VLLS1 recovery). Thus we can write following code: /* Write your code here */   if (RCM_SRS0 == 0x01) { /* test the reason of reset - wakeup on VLLS */     if(PMC->REGSC &  PMC_REGSC_ACKISO_MASK) {       PMC->REGSC |= PMC_REGSC_ACKISO_MASK; /* VLLSx recovery */     }     for (blink_count = 0; blink_count < LED_BLINK; blink_count++) {         // green LED blinking         GPIO_DRV_ClearPinOutput(kGpioLED2);         //GPIOB_PCOR = (GPIOB_PCOR & (~GPIOB_PSOR_MASK)) | GPIOB_PSOR_VALUE;         for (i = 0; i<40000; i++);         GPIO_DRV_SetPinOutput(kGpioLED2);         //GPIOB_PSOR = (GPIOB_PSOR & (~GPIOB_PSOR_MASK)) | GPIOB_PSOR_VALUE;         for (i = 0; i<40000; i++);     }     // set the next alarm in "RTC_ALARM_TIMEOUT_SEC" seconds (clear also the TAF flag)    RTC_HAL_SetAlarmReg(RTC_BASE,RTC_HAL_GetAlarmReg(RTC_BASE)+RTC_ALARM_TIMEOUT_SEC);   } else {     /* power-on reset */     /* switch the green LED on */     GPIO_DRV_ClearPinOutput(kGpioLED2);     /* wait a while */     for (i = 0; i<40000; i++);     /* switch the green LED off */     GPIO_DRV_SetPinOutput(kGpioLED2);   } In case of VLLS1 recovery we acknowledge the pin isolation ACKISO bit in the PMC_REGSC register. This bit must be cleared to allow normal run mode of all pins. Then five blinking of the green LED follows (it is just a simple code for demo purposes only; you can write your own more sophisticated code for blinking by TPMx device with Init_TPM component if you want). In case of POR reset one blink of the green LED is processed. When the reset/wake-up state is served by our application code the VLLS1 mode can be entered. As the first step, we need to be sure that there are not any interrupt flags set to wake-up the CPU from VLLS1 mode so we clear LLWU and SW2 pin (PTB0) interrupt flags and then we enter VLLS1 mode by using enter_vllsx function: /* clear LLWU flag for the selected pin 4 - PTB0 */ LLWU_F1 |= LLWU_F1_WUF4_MASK;   /* clear interrupt flag of the SW2 pin - PTB0 */ PORTB_PCR0 |= PORT_PCR_ISF_MASK; // enter the VLLS3 //enter_vllsx((smc_por_option_t)NULL,kSmcStopSub3); // enter the VLLS0 - RTC and LPTMR do not work becuase of external crystal clock source does not work in the VLLS0 mode //enter_vllsx(kSmcPorEnabled, kSmcStopSub0); // enter the VLLS1 enter_vllsx((smc_por_option_t)NULL,kSmcStopSub1); // switch the green LED on - error state when the VLLSx mode is not entered GPIO_DRV_ClearPinOutput(kGpioLED2); There is also code for switching on the green LED in case the VLLS1 mode is not entered (indication of the error state). The enter_vllsx function is defined by the following way (it is used existing function from a demo KSDK demo example): /* * VLLSx mode entry routinue */ static void enter_vllsx(smc_por_option_t PORPOValue, smc_stop_submode_t VLLSValue) {        smc_power_mode_config_t smcConfig;        /* set power mode to specific VLLSx mode */        smcConfig.porOption = true;        smcConfig.porOptionValue = (smc_por_option_t) PORPOValue;        smcConfig.powerModeName = kPowerModeVlls;        smcConfig.stopSubMode = (smc_stop_submode_t) VLLSValue;        SMC_HAL_SetMode(SMC_BASE, &smcConfig); } It is all code we need for our low power demo application. The application can be built and run now. Debugging The application does not contain any debug connection by default in KDS 1.1.1. The KDS 2.0.0 contains debug configurations but the settings must be updated according to following description. We just need to add (modify) a debug configuration for our FRDM-KL03Z board and Open SDA Segger j-link debugger. Open the context menu of the Low power demo KL03 project in the Project Explorer window and select Debug As > Debug Configurations .... In the Debug Configuration window double click on the GDB SEGGER J-Link Debugger item and a new Low power demo KL03 Debug configuration is created. Select the Debugger tab and enter the Device name: MKL03Z32xxx4 (you can find the correct CPU name in list when you open Support device names link that is located to right of this item). Uncheck Allocate console for semihosting and SWO (SWO is not support by OpenSDA SEGGER J-link). Go to on Startup tab and uncheck the Enable SWO option (SWO is not supported by OpenSDA SEGGER J-link). Click on the Apply and Debug button and the debugger starts (you must have the FRDM-KL03Z board connected to the workstation). You can now start the application (click on the Resume button) and check the functionality. The debugger is disconnected due to VLLS1 mode entry. But the application run and can be used. If you want to connect a button for the LPTMR pulses generating you can connect one pin of the button to the PTB6 on pin #4 of 8-pins connector J1 and the second pin of the button to the GND to the pin #7 of the 10-pins connector J2, see below: You can use this demo application as a start point of your real low power application. I hope it will help you and save your time of your first low power application implementation in the Processor Expert. There is also possible to measure power consumption of the CPU in VLLS1 mode. It is described in the FRDM-KL03 User Guide. Just unsolder R27 and R28 and solder a header pins to J10 position of the board. You must use jumper for J10 now to connect power supply for the CPU and when the jumper is removed you can use these two pins to measure the energy consumption of the CPU (e.g. by a multimeter).

Since I want to use some settings of the provious project, I find there are two ways which both don't work. I select the "The LCD"  example project which locals in"\\\Freescale\CW MCU v10.3\MCU\CodeWarrior_Examples\Processor_Expert\Kinetis\TWR-K40X256\LCD". First gererate code,  build and run the project with success. Then I save the processor setting as template and add  it in a empty PE project from the "Component Library", Generate Processor Export code with error "Incorrect Tool Chain Select", I check the new project propeties and change the "Current toolchain" as "ARM  toolchain"  in correpondence with the previous project.  Regenerate the code , there still exit 9 errors in the _arm_start.cfile . Description Resource Path Location Type Undefined : "exit" __arm_start.c /PE_use_template/Project_Settings/Startup_Code line 287 C/C++ Problem Link failed. PE_use_template C/C++ Problem mingw32-make: *** [PE_use_template.elf] Error 1 PE_use_template C/C++ Problem Undefined : "__aeabi_unwind_cpp_pr1" PE_use_template line 0, external location: E:\CW_workspace\PE_use_template\RAM\Cpu_c.obj C/C++ Problem Undefined : "__call_static_initializers" __arm_start.c /PE_use_template/Project_Settings/Startup_Code line 251 C/C++ Problem Undefined : "__copy_rom_sections_to_ram" __arm_start.c /PE_use_template/Project_Settings/Startup_Code line 231 C/C++ Problem Undefined : "__init_registers" __arm_start.c /PE_use_template/Project_Settings/Startup_Code line 179 C/C++ Problem Undefined : "__init_user" __arm_start.c /PE_use_template/Project_Settings/Startup_Code line 257 C/C++ Problem Undefined : "memset" __arm_start.c /PE_use_template/Project_Settings/Startup_Code line 229 C/C++ Problem Second, when I use export "Component Setting"  there still exist the same problems. Can anyone give some hints or advice to this problem?:D

Learn how to incorporate Processor Expert's generated code into an IAR Embedded Workbench project.

This tutorial will show step-by-step how to create a simple Processor Expert project that periodically toggles an output pin using a timer output without writing a single line of code. The FRDM-KL25 board is used with one of the LEDs (blue) connected to the Timer/PWM Module 0 (TPM0), channel 1. Timer Operation Description The Timer/PWM Module 0 (TPM0) provides (besides other features) a counter with variable period (modulo), compare register an output pin suitable for the goal of periodic toggling. The counter will be configured to continuously run in modulo range with a 300ms period, the output will be set when counter reaches the compare register value (150ms) and cleared when the counter resets. The following picture describes the operation: Creating the Project First, create a new project with Processor Expert for KL25 configured as described in the tutorial Creating Processor Expert Project for FRDM-KL25 Switch to Components Library view and its Categories tab and add the TimerUnit_LDD component from the category Logical Device Drivers / Timer by double-clicking on it or selecting pop-up menu command ‘Add to project’. The component appears in the Components view: Use the Rename component command from the TU1’s context menu and change the name to BlueLED. : Double click the component to open it in the inspector and configure the properties according to the following picture: Invoke code generation by clicking on the Generate Processor Expert Code button in the Components view of the project: The generated code is present in the Generated_Code folder of the project: Note: The generated code contains automatic initialization provided by Processor Expert configuring all needed registers, so it's not necessary to write any user code. Build the project using the Project / Build All. After the successful build, you can connect the FRDM-KL25 board and run the application by clicking the "Debug" icon and after the code gets loaded into the board the "Resume" button. The LED should start periodically blinking with blue color.

The attached document shows how tou use Processor Expert Driver Suit to generate code for IAR. You can see details in the notes at the botton of the slides. Best regards, Carlos

Hey everyone! If you are looking for concise steps to create and apply a patch in a yocto build, this article will serve you well. The reference taken in this article is of iMX93EVK yocto build. For this exercise, we are modifying a lpspi dts file in the BSP and creating a patch file but you may apply the same steps to other files in the BSP as well. Step-1 Make changes to the dts file in your directory example - arch/arm64/boot/dts/freescale/imx93-11x11-evk-lpspi.dts Step-2 In your yocto build, go to the git folder  cd imx-yocto-bsp-home/build_11x11/tmp/work/imx93_11x11_lpddr4x_evk-poky-linux/linux-imx/6.1.36+gitAUTOINC+04b05c5527-r0/git Step-3 Execute 'git diff' to check the difference between your changes and the default ones    Check the status by executing 'git status'     Step-4 Execute 'git add <file>'  , 'git commit -m <message>', and 'git format-patch -1' to add a file and create a git format patch file for your changes.   copy the generated patch file to a location which yocto build look for the patches Example- My yocto build looks for the patch in various locations, one of them is this one :- sources/meta-imx/meta-bsp/recipes-kernel/linux/files, so after creating the directory 'files', we can move the patch file to this folder    Step-5 Edit the .bb file for linux recipes-kernel for example - Open  /home/nxg06361/imx-yocto-bsp-home/sources/meta-imx/meta-bsp/recipes-kernel/linux/linux-imx_6.1.bb  for editing Append the patch file name to the SRC_URI variable     You can also verify that your patch has been successfully applied or not by doing 'git log'   Voila ! that's all you need to do in order to create and apply a git patch for your yocto build.

This document describes the manual conversion of a (CodeWarrior MCU 10.6) Processor Expert project by creating of a new project in KDS 3.0.0 for the same target MCU and copying of Processor Expert project and user source code. This options of the CodeWarrior (or Driver Suite) project conversion provide an easy way how to convert the project but all customized settings of compiler, linker and libraries must be set manually in the new KDS 3.0.0 project again (this configuration will not be migrated). The migration of the whole CodeWarrior project is described in the document CW MCU 10.6 Processor Expert projects migration into KDS 3.0.0 Steps: 1. Create a new Kinetis project for the same target MCU (navigate to menu File > New > Kinetis Project). Write a new project name (you can write the same name of the original project). Select the same target MCU (or a target board that use the same target MCU). Kinetis SDK – select None Check Processor Expert Select the compiler that is available (installed) in your KDS 3.0.0 installation (GNU C Compiler is available by default). 2. Remove all Processor Expert components from the project (delete all CPUs and components if included). All components will be imported from the original project. 3. In the Components windows, navigate to the View Menu > Import > Import Processor Expert Component Settings 4. In the Import Processor Expert Component Settings windows, click on Browse button 5. In the dialog, select *.pe file extension and select the ProcessorExpert.pe from the original CodeWarrior Processor Expert project. Click on the Open button. 6. In the Import Processor Expert Component Settings windows select the target project (the new project). 7. The window contain list of all components that can be imported (added). You can select components that can be omitted (all will be imported by default). 8. Click on the Finish button. All selected components are imported and no warnings and errors should be reported. 9. Open the folder with the original CodeWarrior project and drag-and-drop source code files (copy files) from the  CodeWarrior project into the new project created in KDS (select Copy files).   Please note, that CodeWarrior projects have the main() function in the ProcessorExpert.c file but the Kinetis Project uses the main.c (copy the content or you can rename the copied ProcessorExpert.c file) . 10. If necessary you can customize the project settings of the project by using Properties (in the Project Explorer window open the context menu of the project and select Properties). You can select the settings that are required by your application (optimization level, adding path to external libraries and so on). 11. Generate the Processor Expert code and Build the application. When all source code is copied (and customized settings and paths are properly set) the application is compiled without any errors and warnings. Debugger connection are pre-configured in the new Kinetis Project in KDS 3.0.0 by default.

Trigger Description Module implementing mini threads using timer based callbacks (triggers) Component Trigger.PEupd Dependencies LowPower License License : Open Source (LGPL) Copyright : (c) Copyright Erich Styger, 2011, all rights reserved. This an open source software implementing triggers using Processor Expert. This is a free software and is opened for education, research and commercial developments under license policy of following terms: * This is a free software and there is NO WARRANTY. * No restriction on use. You can use, modify and redistribute it for personal, non-profit or commercial product UNDER YOUR RESPONSIBILITY. * Redistributions of source code must retain the above copyright notice.

BootLoaderUSB Description Bootloader over USB Component BootLoaderUSB.PEupd Dependencies Wait, BootLoaderUSB, S19 License This component is based on the Freescale Application Note AN3748. The copyright notice of the original file is provided below: /****************************************************************************** * * (c) copyright Freescale Semiconductor China Ltd. 2008 * ALL RIGHTS RESERVED * * File Name: SCSI_Process.C * * Description: This file is to handle SCSI command * * Assembler: Codewarrior for HC(S)08 V6.2 * * Version: 2.3 * * Author: Patrick Yang * * Location: Shanghai, P.R.China * * * UPDATED HISTORY: * * REV YYYY.MM.DD AUTHOR DESCRIPTION OF CHANGE * --- ---------- ------ --------------------- * 1.0 2008.01.02 Patrick Yang Initial version * 2.0 2008.06.10 Derek Snell Modified to work with USB MSD bootloader * 2.1 2008.08.15 Derek Snell Fixed SCSI issue to work with non-XP OSs * 2.2 2008.08.25 Derek Snell Renamed SCSI Inquiry to "Freescale USB Bootloader" * Stopped accepting write data from host after successful S19 transfer * ******************************************************************************/ /* Freescale is not obligated to provide any support, upgrades or new */ /* releases of the Software. Freescale may make changes to the Software at */ /* any time, without any obligation to notify or provide updated versions of */ /* the Software to you. Freescale expressly disclaims any warranty for the */ /* Software. The Software is provided as is, without warranty of any kind, */ /* either express or implied, including, without limitation, the implied */ /* warranties of merchantability, fitness for a particular purpose, or */ /* non-infringement. You assume the entire risk arising out of the use or */ /* performance of the Software, or any systems you design using the software */ /* (if any). Nothing may be construed as a warranty or representation by */ /* Freescale that the Software or any derivative work developed with or */ /* incorporating the Software will be free from infringement of the */ /* intellectual property rights of third parties. In no event will Freescale */ /* be liable, whether in contract, tort, or otherwise, for any incidental, */ /* special, indirect, consequential or punitive damages, including, but not */ /* limited to, damages for any loss of use, loss of time, inconvenience, */ /* commercial loss, or lost profits, savings, or revenues to the full extent */ /* such may be disclaimed by law. The Software is not fault tolerant and is */ /* not designed, manufactured or intended by Freescale for incorporation */ /* into products intended for use or resale in on-line control equipment in */ /* hazardous, dangerous to life or potentially life-threatening environments */ /* requiring fail-safe performance, such as in the operation of nuclear */ /* facilities, aircraft navigation or communication systems, air traffic */ /* control, direct life support machines or weapons systems, in which the */ /* failure of products could lead directly to death, personal injury or */ /* severe physical or environmental damage (High Risk Activities). You */ /* specifically represent and warrant that you will not use the Software or */ /* any derivative work of the Software for High Risk Activities. */ /* Freescale and the Freescale logos are registered trademarks of Freescale */ /* Semiconductor Inc. */ /*****************************************************************************/