The components of this kit will provide students with the basic materials. The challenge for teams is to collaborate with peers to design the interconnecting hardware and to create the algorithms that will give a vehicle the competitive edge. The sensor interfacing, vehicle navigation, signal processing and control systems techniques students will learn can be applied to most embedded systems. Included in the Freescale Cup Kit Part Number: TFC-KIT Model Car chassis Line Scan Camera Interface and Motor Controller Board   Part Number: TFC-5604B-KIT  All pieces inside TFC-KIT Freescale Microcontroller Board (Qorivva MPC5604B) Getting Started: 1. Purchase the kit 2. Explore the tutorials and reference materials Take the Freescale Cup Training Tutorials Browse through the sample code within the tutorials Download the reference manuals for your microcontroller, many which are linked to from this wkik Navigate to the training modules and videos of the Designing and programming your Cup Car: Hardware 1.Tools needed: In addition to what is provided in the kit, you will need several other tools you will need to design and build a working intelligent car. Must have Soldering iron Solder Solder wick Wire (gauges) Oscilloscope Useful Power Supply Solder remover bulb Oscilloscope DMM Optional Access to a Rapid Prototyping Machine Software such as Eagle or PCBArtist 2.Electronics Components you will want to obtain soon Software What we’ve provided The software provided in this wikiwill get you started in your task of creating an intelligent car. We have included files which you can load onto your microcontroller which blink a led, activate the motor and servo, as well as a small simple driver for the camera which sends it the proper signals and reads data into your microcontroller. What you need to design Your job will be to connect the various components together, refine and add to the code we have provided and create a working intelligent car. Start thinking about how you will determine where the line is on the track, what algorithm you will use for steering and deciding how much power you want to send to your motor. You may want to read up on PID controllers, or other types of control systems. Are there any special features that you might want to add to your car – such as real time debugging? Those features will require extra work and up front planning. Planning and Teamwork You might not have the time to document all your designs and concepts properly before sitting down to code or to create a piece of hardware, but you might want to create an ordered list of all the different tasks which will be necessary to finish the car, who will do those items, and when you want each task to be finished. A schedule will help you determine if you are on track with your goals …

This tutorial covers the details of Turning A Servo on the Kinetis K40 using TWR-K40x256-KIT evaluation board. Overview In this exercise you will build a “bare metal” (no RTOS) application which turns a servo, targeting a Freescale K40 board. You will: Create the Servo code in CodeWarrior Build the Servo project Download and run the code on a Kinetis K40 Tower System board Learn how to utilize the FlexTimer module to control a Servo   To successfully complete this exercise you need the following board and development environment. The K40 Tower card, TWR-K40x256 Tower Elevator Panels Servo Prototyping Board Power to your servo - either utilize the 7.2v Nicad Battery or a DC power supply CodeWarrior for Microcontrollers 1. Hardware 2. Create a New CodeWarrior Project 3. Build the Code 4. Download/Debug/Run 5. Learning Step: Servo Code Description Example Code Variables Init_PWM_Servo PWM_Servo PWM_Servo_Angle Set Up a Look-Up Table for Servo Angles Other K40 Tutorials: Links 1. Hardware   The first step of this tutorial requires you read the Turn A Servo article for background information on servo's, timer modules, PWM signals and counters. You will need to connect your servo to the microcontroller and also to a separate power source. 2. Create a New CodeWarrior Project The next step is to create a new project (or add this code to an existing project). 3. Build the Code If you have more than one project in your project view, make sure the proper project is the focus. The most reliable way to do this is to right click the project and choose Build Project as shown below. You can also go to the Project menu and choose the same command. If you encounter errors, look in the Problems view and resolve them. You can ignore any warnings. 4. Download/Debug/Run This link shows a video of the servo turning the wheels from left to right in small increments http://www.youtube.com/watch?v=QgwASk9DHvU&feature=relmfu 5. Learning Step: Servo Code Description Your code will sweep your servo from max to minimum angular position, and then back again continuously. Example Code This code sets up the Pulse Width Modulation Timer Module for use by a servo. It is set to utilize Edge-Aligned PWM, and this file properly configures the period, and pulse width for use by the other modules Several important functions are contained in this file: 1. Init_PWM_Servo () - initializes the timer module 2. PWM_Servo (double duty_Cycle) - enter the desired duty cycle setting for the servo 3. PWM_Servo_Angle (int Angle) - enter the desired angle for the servo Straight forward - PWM_Servo_Angle (45) Full left - PWM_Servo_Angle (90)Full right - PWM_Servo_Angle (0)   4. Servo_Tick - interrupt routine which executes once/servo period PWM_Servo (double duty_Cycle) Init_PWM_Servo () PWM_Servo_Angle (float Angle) void ServoTick() Variables FTM0_CLK_PRESCALE TM0_OVERFLOW_FREQUENCY Pulse_Width_Low Pulse_Width_High Total_Count Low_Count Scale_Factor Angle Init_PWM_Servo Void Init_PWM_Servo () { //Enable the Clock to the FTM0 Module SIM_SCGC6 |= SIM_SCGC6_FTM0_MASK;  //Pin control Register (MUX allowing user to route the desired signal to the pin.  PORTC_PCR4  = PORT_PCR_MUX(4)  | PORT_PCR_DSE_MASK; //FTM0_MODE[WPDIS] = 1; //Disable Write Protection - enables changes to QUADEN, DECAPEN, etc.  FTM0_MODE |= FTM_MODE_WPDIS_MASK; //FTMEN is bit 0, need to set to zero so DECAPEN can be set to 0 FTM0_MODE &= ~1; //Set Edge Aligned PWM FTM0_QDCTRL &=~FTM_QDCTRL_QUADEN_MASK;  //QUADEN is Bit 1, Set Quadrature Decoder Mode (QUADEN) Enable to 0,   (disabled) // Also need to setup the FTM0C0SC channel control register FTM0_CNT = 0x0; //FTM Counter Value - reset counter to zero FTM0_MOD = (PERIPHERAL_BUS_CLOCK/(1<<FTM0_CLK_PRESCALE))/FTM0_OVERFLOW_FREQUENCY ;  // Count value of full duty cycle FTM0_CNTIN = 0; //Set the Counter Initial Value to 0 // FTMx_CnSC - contains the channel-interrupt status flag control bits FTM0_C3SC |= FTM_CnSC_ELSB_MASK; //Edge or level select FTM0_C3SC &= ~FTM_CnSC_ELSA_MASK; //Edge or level Select FTM0_C3SC |= FTM_CnSC_MSB_MASK; //Channel Mode select //Edit registers when no clock is fed to timer so the MOD value, gets pushed in immediately FTM0_SC = 0; //Make sure its Off! //FTMx_CnV contains the captured FTM counter value, this value determines the pulse width FTM0_C3V = FTM0_MOD; //Status and Control bits FTM0_SC =  FTM_SC_CLKS(1); // Selects Clock source to be "system clock" or (01) //sets pre-scale value see details below FTM0_SC |= FTM_SC_PS(FTM0_CLK_PRESCALE); /******begin FTM_SC_PS details **************************** * Sets the Prescale value for the Flex Timer Module which divides the * Peripheral bus clock -> 48Mhz by the set amount * Peripheral bus clock set up in clock.h *  * The value of the prescaler is selected by the PS[2:0] bits.  * (FTMx_SC field bits 0-2 are Prescale bits -  set above in FTM_SC Setting) *  *  000 - 0 - No divide *  001 - 1 - Divide by 2 *  010 - 2 - Divide by 4 *  011 - 3 - Divide by 8 *  100 - 4 - Divide by 16 *  101 - 5 - Divide by 32 *  110 - 6 - Divide by 64 - *  111 - 7 - Divide by 128 *  ******end FTM_SC_PS details*****************************/ // Interrupts FTM0_SC |= FTM_SC_TOIE_MASK; //Enable the interrupt mask.  timer overflow interrupt.. enables interrupt signal to come out of the module itself...  (have to enable 2x, one in the peripheral and once in the NVIC enable_irq(62);  // Set NVIC location, but you still have to change/check NVIC file sysinit.c under Project Settings Folder } PWM_Servo Void PWM_Servo (double duty_Cycle) {          FTM0_C3V =  FTM0_MOD*(duty_Cycle*.01); } PWM_Servo_Angle //PWM_Servo_Angle is an integer value between 0 and 90 //where 0 sets servo to full right, 45 sets servo to middle, 90 sets servo to full left void PWM_Servo_Angle (float Angle) {    High_Count = FTM0_MOD*(Pulse_Width_High)*FTM0_OVERFLOW_FREQUENCY;    Low_Count = FTM0_MOD*(Pulse_Width_Low)*FTM0_OVERFLOW_FREQUENCY;    Total_Count = High_Count - Low_Count;    Scale_Factor = High_Count -Total_Count*(Angle/90);     FTM0_C3V = Scale_Factor; //sets count to scaled value based on above calculations } Set Up a Look-Up Table for Servo Angles int main(void) {   //Servo angles can be stored in a look-up table for steering the car.   float table[n] = { steering_angle_0;    steering_angle_1;    steering_angle_2;   ……    steering_angle_n-1    };   Steering_Angle = table[x];   PWM_Servo_Angle (Steering_Angle); // Call PWM_Servo_Angle function. } Other K40 Tutorials: K40 Blink LED Tutorial K40 DC Motor Tutorial Kinetis K40: Turning A Servo K40 Line Scan Camera Tutorial Links Kinetis K40 TWR-K40X256-KIT

In this training video we will decompose an NTSC video signal to gaining understanding of how to capture video data from a "analog" camera.

INTRODUCTION Hi everyone, Making/Developing/Porting a Bootloader is a tedious task for newbies (even for professionals) and inexperienced hobbyists who wish to use them on their custom hardware for rapid prototyping. After searching a lot on different forums I came to a conclusion that I cant develop a bootloader just like that so my next option was porting ,that too wasnt easy if you are going with old bootloaders with limited support. I then found a very easy and efficient way of rapid software development platform that can be used on almost any IDE (Keil,Codewarrior,KDS,etc.) and can be used to develop softwares like USB MSD Bootloaders,Serial Bootloaders and other applications for almost all Freedom Development Boards ,Freescale Kinetis MCUs (on a Custom Development Board ) with minimal ARM Programming Knowledge, which is perfect for newbies like me who are just starting with ARM Development using freescale or other boards.See Welcome to the homepage of the µTasker operating system with integrated TCP/IP stack, USB and target device simulator Now my project was to make custom board using MK22DX256VLF5 (48 LQFP) MCU ,my board is a rather a simple one using basic filtering circuits for powering the MCU and almost all the pinouts given as hardware pins on the dev board.Somehow I was able to flash my first blink code using Keil IDE using the OpenSDA circuitry of FRDM-KL25Z (J-11 trace cut ) with CMSIS-DAP firmware (OpenSDA app ) loaded on to it using SWD Programming. With the steps mentioned below I'll show you how to port a Mass Storage Device (MSD) Bootloader using uTasker project from scratch. REQUIREMENTS Programmer(Hardware) or Emulated Programmer(OpenSDA apps): Segger Jlink, P&E Multilink ,OpenSDA Emulators (Jlink-SDA, CMSIS-DAP,USBDM ) IDE :Keil,Codewarrior, Kinetis Design Studio etc. (I prefer CW 10.6 ) Target MCU: Choose any MCU between Kinetis,Coldfire V2,STM32  (I am using Freescale Kinetis MK22DX256VLF5 ,48 LQFP ) refer - http://www.utasker.com/ PROCEDURE 1. Lets start by downloading the uTasker project/framwork (for Kinetis ) from µTasker Kinetis Developer's Page . Then extract and copy the folder to your CW workspace ,import the project to CodeWarrior IDE, It should look like this. (I am using version 14-9-2015)   2.Next Select "uTaskerSerialLoader_Flash" from the Five build configurations (refer http://www.utasker.com/docs/uTasker/uTaskerSerialLoader.PDF  ).uTaskerBM_Loader is described in http://www.utasker.com/docs/uTasker/uTasker_BM_Loader.pdf This is a very small loader alternative that works together with an initial application. uTaskerV1.4_BM_FLASH is the application to build so that it can be loaded to a loader (including the USB-MSD one). uTaskerV1.4 is a 'stand-alone' version of the application that doesn't work together with a loader (and doesn't need a loader).If you want to build application to load using the USB-MSD loader you need to use uTaskerV1.4_BM_FLASH. after that find the files config.h and ap_hw_kinetis.h.These files define the type of MCU you use. 3.In config.h Select your board or MCU type or the closest MCU resembling the architecture of your own MCU. My MCU  MK22DX256VLF5 was not there so with a little help from mjbcswitzerland  I chose TWR_K21D50M Board settings as TWR-K21D50M module is a development board for the Freescale Kinetis K11, K12, K21 and K22 MCUs. (Note : Be sure to remove or comment any other defined boards ) After Selecting the Board/MCU scroll down to find USB_INTERFACE and USB_MSD_LOADER and make sure that these two are defined (not commented ).This is necessary to enable USB enumeration as Mass storage device. Also comment the following if already defined : HID_LOADER KBOOT_HID_LOADER USB_MSD_HOST This is necessary as we are using our Bootloader in MSD Device Mode not in MSD Host Mode. Also we arent using HID_LOADER and KBOOT. Now open  ap_hw_kinetis.h and Find your selected MCU (in my case its TWR_K21D50M ) So, Find the String "TWR_K21D50M" (or whatever your MCU is ) and see if the follwing lines are defined. #define OSC_LOW_GAIN_MODE #define CRYSTAL_FREQUENCY    8000000  #define _EXTERNAL_CLOCK      CRYSTAL_FREQUENCY #define CLOCK_DIV            4                                      or    #if(..........)         #define CLOCK_MUL        48                                            #define SYSTEM_CLOCK_DIVIDE 2                                      #else         #define CLOCK_MUL        24 #endif     #define USB_CLOCK_GENERATED_INTERNALLY Here comes an integral part of USB MSD Bootloading/Programming.You must be wondering about CRYSTAL_FREQUENCY  8000000 and  CLOCK_DIV   4  .This is the frequency of an external crystal oscillator  (8mhz) connected between EXTAL0 and XTAL0 pins of the Target MCU.If your MCU has an internal oscillator then check whether the latter is defined. refer- https://cache.freescale.com/files/microcontrollers/doc/app_note/AN4905.pdf          http://www.utasker.com/kinetis/MCG.html There are two ways to be able to use USB: 1. Use a crystal between EXTAL0 and XTAL0 - usually 8MHz is used. (with or without load capacitor -both worked for me ) 2. Use a 48MHz oscillator on the USB-CLKIN pin. First one is easier and it worked for me.Since my MCU doesnt have an internal oscillator I have used and External 8Mhz crystal. If you want to use a 16Mhz crystal then just make the following changes : #define CRYSTAL_FREQUENCY    8000000 #define _EXTERNAL_CLOCK      CRYSTAL_FREQUENCY #define CLOCK_DIV            4                                 TO #define CRYSTAL_FREQUENCY    16000000 #define _EXTERNAL_CLOCK      CRYSTAL_FREQUENCY #define CLOCK_DIV            8 Note: The CLOCK_DIV should be such that it prescales the crystal frequency to range of 2-4MHz. Here is the clocking diagram of My MCU.The next diagram shows an oscillator crystal connected externally to my dev board. Next search for "PIN_COUNT" under your corresponding MCU/Board (mine is TWR_K21D50M).My MCU is 48 LQFP with 256kb flash and 32kb SRAM (you have to change them according to your MCU ).So I have changed the following lines                              from   #define PIN_COUNT           PIN_COUNT_121_PIN                         #define SIZE_OF_FLASH       (512 * 1024)                          #define SIZE_OF_RAM          (64 * 1024)                              to   #define PIN_COUNT           PIN_COUNT_48_PIN                      #define SIZE_OF_FLASH       (256 * 1024)                              #define SIZE_OF_RAM          (32 * 1024)  Next if you search for your MCU/Board (in this case TWR_K21D50M) ,you will find this line : #define UART2_ON_E This defines the alternative port for UART2,since many boards doesnt have PORTE ,it can be chaned to other ports. [its not important though] Note : When building the serial loader for a device with small RAM size reduce the define #define TX_BUFFER_SIZE (5512) to 512 bytes so the buffer can be allocated (the large size was used only for some debugging output on a larger device) [loader version :14.9.2015] Now search for the String "BLINK_LED" under your corresponding MCU/Board ( mine is TWR_K21D50M ) .The uTasker Bootloader has a special function ,whenever it is in MSD/LOADER mode it blinks a test LED on the board.This is not important but it can be used for debugging purposes.I have a test LED on my board at PORTB16 .You can also specify hardare pins to force bootloader mode and to stop watchdog timer if you pull SWITCH_3 and SWITCH_2 down to ground respectively.I am setting SWITCH_3 and SWITCH_2 as PORTD7 and PORTD6 respectively. Now on the toolbars go to Project > Properties > C/C++ Build > Settings > Tool Settings > Target Processor :Change it to your MCU type (mine is cortex-m4 ) .Next go to Linker >General and change the linker script file to match your MCU's flash,RAM,Type.I have set mine to K_256_32.ld (Kinetis K type processor with 256kb flash and 32 kb RAM) Apply your changes.Now you are ready to go. 4.  Build your project under SerialLoader_FLASH configuration .If there are no compilation errors then you have done it! (if there are then recheck everything with this guide ) Now Click the Flash programmer icon a and Select Flash File to Target. (if your not getting the icon switch to "DEBUG" perspective view ) Now you may choose your Programmer (or emulated programmer )[connection tab] ,select the correct Flash configuration file ,then browse for the binary file that has been generated under C:\Users\<computer user>\workspace\Kinetis_14-9-2015\Applications\uTaskerSerialBoot\KinetisCodeWarrior\uTaskerSerialBoot_FLASH\uTaskerSerialBoot.bin and Click on "Erase and Program". You may skip Step 5 and go to Step 6. 5.I am using the OpenSDA circuitry of my FRDM-KL25Z (J-11 trace cut ) as a programmer using J-link OpenSDA app. Download the app from SEGGER - The Embedded Experts for RTOS and Middleware, Debug Probes and Production Programmers - OpenSDA / OpenSDA V2 depending on your OpenSDA version (FRDM KL25Z has OpenSDAv1). Refer - Using the Freedom Board as SWD Programmer | MCU on Eclipse 5.1.First Enter bootloader mode and Flash the Jlink sda app into it.Connect the SWD wires from the board to your  Target MCU/Board ,also connect the target board        to the external oscillator.Also connect the FRDM's OpenSDA through USB. (A drive with the name JLINK Should come )                                          5.2. Go to Flash File to target and under connections tab click new. give any name and click new under Target Tab.Then select the target type (your target MCU ,mine is                      K22DX256M5).Then check Execute Reset under Initialization Tab. Click finish.    Now you'll get the option to select connection type ,then choose J-Link/J-Trace for ARM and change the Debug port interface to SWD .If you get the error :connection name is not        unique then just change the name (I have used jlink1).Click Finish.     Now I have set up my connections so I can flash the MCU with Jlink app on my OpenSDA circuitry. 6. Now to verify USB Enumeration of your Custom Board ,connect it to PC using USB and you should get a drive with the name UPLOAD_DISK.

MathWorks is a proud global sponsor of The NXP Cup If you are a member of a NXP Cup team, you have access to a complimentary Software License for MATLAB / Simulink. Visit the NXP Cup - MathWorks Deutschland website to learn more about the Software offering.  Examples for using Simulink in the NXP Cup are packaged with the Simulink Coder Support Package for  FRDM-KL25Z available from the Hardware Support Page.  Additional examples for reading and analyzing live data from the Line Scan Camera are available in the NXP Cup Companion App available on the MATLAB File Exchange.  Additionally, there is an example which uses the Simulink Coder product from MathWorks to target the FRDM-KL25Z. Feel free to use the forum on MATLAB Answers or here below to ask your questions about MATLAB use with The NXP Cup.  You can also email roboticsarena@mathworks.com with any questions.

How to install a servo horn.  More specifically for the Freescale Cup kit. [no audio]

Depending on which MCU Devlopment board you have chosen, you will need to figure out a way to mount this to the chassis. I have seen everything from cardboard, to aluminum, to wood. Below is a template complete with CAD drawings to mount the Qorivva TRK-MPC5604B board and the Motor Board onto the chassis. We use plexiglass for ours, but any other millable material is appropriate. The large hole in the middle is for cables from the servo. We attach the board to the car using the plastic standoffs (you will need them 55 mm long, so in our case, we used the combination of 40 + 15 mm) - see an example (SOS code 10260). To attach both the processor and interface boards the simillar 5mm plastic standoffs were used. Preview (.pdf) CAD file (.dxf)

The file contains the rules for The NXP Cup EMEA 2016-2017 edition of the challenge. Revision 1 dated 13-Jul-2016 For any question : marion.thierry@nxp.com

A microcontroller includes a microprocessor (CPU) as well as a number of other components like RAM, flash and EEPROM to store your programs and constants. While a microprocessor requires external devices to control things like input/output, or timers to implement periodic tasks, and digital to analog converters, a microcontroller is all inclusive. Contrast this all-in-one approach with a typical personal computer which contains an INTEL or AMD CPU, as well as separate chips for RAM, a separate video card, a dedicated hard drive, silicon chips or PCI circuit boards to enable the processor to access USB, serial and video card signals Microcontroller pins are general purpose, whereas CPU pins are specific. This means that each pin is tied to a multiplexer which you must set to choose the particular use for the pin. For example, in a microcontroller, one pin pin might be re-purposed for the following tasks 1. The output of a timer 2. Send a signal to a motor 3. Receive an input from a sensor or analog device Basic Concepts Covered Thus far: Blink an LED - overview of GPIO and setting up the microcontroller Drive a Motor - using the Timer and PWM modules of the microcontroller Turn a Servo - More details on using timer modules and PWM to control a servo Obtain Data from the Line Scan Camera - ADC Setup and GPIO Bit Blasting to create clock and pulse signals controlling the line scan camera I2C tutorial - Using I 2 C to communicate with various sensors using the K40 Button - An overview of how to implement a simple button Additional Concepts we would like to add to the Wiki: Timer Modules PWM watchdog-timer memory

This video will examine how can design speed sensing into their vehicle platform.   An example of magnet and sensor placement is shown.

One option for mounting the camera on the Freescale Cup car.  The only additional components you need are two zip ties. [no audio]

Harvard Extension School CSCI E-251, Fall 2012: Principles of Operating Systems Final Project Presentations Presentation by Eric Pedersen