Fast And Furious

Made by EckerChris / 3D Printing / Displays / Robotics / Vehicles

About the project

We are two Master-Students at the University for Applied Sciences in Landshut, Germany and we want to participate at the NXP Cup with our car named Gustl. This Electromaker-project contains the development and building process of our autonomous driving model car. We're trying to get a place on the podium at the next NXP Cup.

NXP Cup Electromaker Innovation Challenge 2021 contest winner

Project info

Difficulty: Difficult

Platforms: DFRobot, NXP, Mouser, Arm

Estimated time: 5 months

License: GNU General Public License, version 3 or later (GPL3+)

Items used in this project

Hardware components

	DFRobot ROB0165 Chassis with brushless motors and servo	x 1
	NXP OM13098: LPCXpresso54628 Development board	x 1
	Vishay O128O064JLPP3N000 OLED display	x 1
	Several Custom 3D Printed extension components Bumper, side skirts, several fastenings etc.	x 1

Software apps and online services

	NXP MCUXpresso IDE, SDK Software development toolchain
	FreeRTOS Realtime operating system running on MCUs
	BLHeliSuite Software for configuring motor controllers (ESCs)

Hand tools and fabrication machines

	3D Printer	x 1
	Drill	x 1
	Several Screwdrivers Hexagon, Phillips, Pozidrive...	x 1

Story

NXP Cup

The NXP Cup let students get creative and design autonomous race cars to compete with each other.

The cup has 5 different challenges whereby only the timed race is mandatory:

For more information about the cup visit https://community.nxp.com/groups/tfc-emea.

About us

Matthias and me, Christian are master students of electronics engineering at the University of Applied Sciences Landshut, Germany. We both graduated as bachelor of engineering this year. The participation at the NXP Cup is also our compulsory project for the first master's semester. We are using some parts for our project from our predecessor to save time and to be able to focus on our own goals.

Goals

- Take part in the NXP Cup and make it onto the podium

- Develop an easy understandable code

- Be as fast as possible

- Gain more experience with real time operating systems

- Gain more experience with programming MCUs

Concept

At the beginning, the vehicle will be assembled using the DFRobot ROB0165 kit. The code will be put together from existing previous projects and will be optimized. The major focus is on a clearer structure of the code and a better traceability through commenting on the code. The coding will be done piece by piece, starting with the control of the BLDC-Motors. When the motors are finally running and the speed can be varied via the pulse-width modulation the next part which will be programmed is the steering. When the car is able to set different steering angles the display will be programmed. After implementing the Car Control Menu the next step will be the camera for detecting the road. The last step will be the ultrasonic board for detecting obstacles on the road.

BLDC-Motors

The two BLDC motors for the car are both controlled by an ESC (electronic speed control). The ESC needs the batteryvoltage as power supply and a PWM signal (pulse width modulation) with a pulse width of 1ms to 2ms and a period time of 20ms (50Hz). At fist we thought it would be easy and we only had to set a timer for pulse width modulation. But we were wrong.

Startup sequence:

The ESC needs a PWM start sequence to detect the pulse width for full speed and zero speed. The following figure shows the startup sequence which the ESCs need. When the power supply of the ESCs is switched on the BLDC Motor beeps three times (low tone, middle tone, high tone). Then the ESC needs to detect the PWM signal. When detected the motor beeps once (low tone). After that the PWM signal must briefly have a larger pulse width before it is again reduced to the value for zero speed. After detecting the zero throttle value the motor beeps the fifth time (high tone) and any throttle value can be set.

However, the theory could not be implemented in practice because we didn't know the settings for the high and low PWM-signals in the ESC. We tried the sequence "PowerOn (3 beeps following) --> 1ms pulse width for 2s (1 beep following) --> 1.5ms pulse width for 2s --> 1ms for 3.5s" but there was no fourth beep. Nothing we did was helpful.

At the end we had to configure the ESCs because we didn't knew the standard settings. The documentation of the ESCs is unlikely very bad. We carried out the configuration of the ESCs via the BLHeliSuite. The following figure shows the parameters and their values that we have set.

We set the low value of the PWM pulse width to 1100µs and the high value to 1900 µs. The start sequence we are using is "PowerOn --> 1ms PWM for 2s --> 1.5ms PWM for 2s --> 1ms PWM for 3.5s". The start sequence is working, all five beeps can be heard. The PWM pulse width times for full throttle and zero throttle are 1.9ms and 1.1ms. The problem with 1.1ms is that the generated PWM signal is not as precisely as wanted. So the PWM pulse width for zero throttle has to be a little below 1.1ms.

Coding:

The coding of the vehicles drive system is contained in two files, the "drive.c" and "drive.h" (see attachement). The file "drive.c" contains the Timer initialization for the PWM signal and the startup sequence. "drive.h" contains the parameters for the initialization, the parameters for full and zero throttle and the function prototypes.

Steering

For the steering of the vehicle we are using the servo motor of the DFRobot ROB0165 kit. A servo is controlled with a PWM signal just as the BLDC motors. The pulse width is also between 1ms and 2ms. While testing the servo we found out that you can also set less than 1ms or more than 2ms for the PWM pulse width. This helps to achieve the maximum possible steering angle. The middle value (about 1.5ms) corresponds to zero degree steering angle. Because the kit is not manufactured very precisely, we determined the value for the middle position by trying out. The result was 1.486ms. The maximum amounts to 2.08ms and the minimum to 0.91ms (under minimum or over maximum --> Hardware Crash).

Coding:

The coding of the vehicles steering system is contained in two files, the "servo.c" and "servo.h" (see attachement). The file "servo.c" contains the Timer initialization for the PWM signal and a demo task. "servo.h" contains the parameters for the initialization, the parameters for minimum, maximum and zero steering angle and the function prototypes.

HMI

Camera

Ultrasonic Board

Speed Measurement

Lane Keeping Control

CAD, enclosures and custom parts

Controller mount

This is the mount for the development board

ESC mount

This is the mount for a motor controller (ESC)

HMI mount

This is the mount for the HMI board

Front bumper top

This is the top part of the Front bumper

Side skirts

These are the side skirts which are also used as battery pack mount

Display cover

This is the cover of the display

Single PCB mount

This is the mount for the power PCB

Ultrasonic board mount

This is the mount for the ultrasonic board

HMI button

This is the button for HMI control

Camera mount camera

This is the part of the camera mount which is attached to the camera

Camera mount pole

This is the part of the camera mount which is attached to the pole

Front bumper bottom

This is the bottom part of the front bumper

Battery pack mount

This is the mount for the battery pack

Code

Github project link

This is the link to the github project hosting the code fopr this NXP-Cup project: https://github.com/CEcker94/NXP_Gustl_SumEck

servo.h

This file contains the parameters for minimum, maximum and zero steering angles and the function prototypes

/*****************************************************************************************************/
/*****************************************************************************************************/
/*****             Erstellt von Summer Matthias und Ecker Christian am 20.11.2020                *****/
/*****                                                                                           *****/
/***** Funktionen zur Initialisierung des ServoMotors für die Lenkung                            *****/
/***** CTIMER1 PWM 2 Channel   --> Zum Lenken in CTIMER1->MSR[2] schreiben                       *****/
/*****                         --> Nur Werte von 200000 bis 459000 verwenden!!!                  *****/
/*****                         --> 200000 < x < 327000 -> Links Lenken                           *****/
/*****                         --> 327000 < x < 459000 -> Rechts lenken                          *****/
/***** Enthält auch DemoTask mit Links-Rechts-Mitte Lenkeinschlag                                *****/
/*****                                                                                           *****/
/***** Servo PWM an Pin P[3][2] und J13 Pin11 auf dem Board                                      *****/
/*****************************************************************************************************/
/*****************************************************************************************************/


#include "fsl_ctimer.h"
#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"
#include "board.h"



/* Definition of channel 2 duty  --> on ticks*/
#define CTIMER1_PWM_0_DUTY 4400000

/* Definition of PWM period --> whole period ticks*/
#define CTIMER1_PWM_PERIOD 4400000

/* Definition of channel 2 ID */
#define CTIMER1_PWM_0_CHANNEL kCTIMER_Match_2


//max left steering value //Attention!! If less than 200000 -> 0,91ms--> crash
#define SERVO_PWM_LeftValue 200000

//max right steering value //Attention!! If more than 459000 -> 2,08ms --> crash
#define SERVO_PWM_RightValue 459000

//zero degree steering angle
#define SERVO_PWM_MiddleValue 327000


void SERVO_Init(void);
void CTIMER1_Init(void) ;
void SERVO_Demo(void *pvParameters);

drive.h

This file contains all parameters for the initialization, the parameters for full and zero throttle and the function prototypes

/*****************************************************************************************************/
/*****************************************************************************************************/
/*****             Erstellt von Summer Matthias und Ecker Christian am 04.12.2020                *****/
/*****                                                                                           *****/
/***** Funktionen zur Initialisierung der BLDC-Motoren für den Antrieb                           *****/
/***** CTIMER3 PWM 0/2 Channel 	--> Zum Fahren CTIMER1->MSR[2](Right Wheel) schreiben			 *****/
/***** 							--> und CTIMER1->MSR[0](Left Wheel) schreiben                    *****/
/*****                         	--> Nur Werte von 240000 bis 418000 verwenden!!!                 *****/
/*****                                                                                           *****/
/***** left BLDC PWM an Pin P[3][10] und J13 Pin7 auf dem Board    								 *****/
/***** right PWM an Pin P[0][27] und J13 Pin12 auf dem Board                                     *****/
/*****************************************************************************************************/
/*****************************************************************************************************/


#ifndef DRIVE_DRIVE_H_
#define DRIVE_DRIVE_H_

#include "fsl_ctimer.h"
#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"
#include "board.h"


#define SOURCE_CLOCK CLOCK_GetFreq(kCLOCK_CoreSysClk)


/* Definition of channel 2 duty  --> on ticks*/
#define CTIMER3_PWM_0_DUTY 4400000

/* Definition of PWM period --> whole period ticks*/
#define CTIMER3_PWM_PERIOD 4400000

/* Definition of channel 0 ID */
#define CTIMER3_PWM_LEFT_CHANNEL kCTIMER_Match_0

/* Definition of channel 2 ID */
#define CTIMER3_PWM_RIGHT_CHANNEL kCTIMER_Match_2

//Init High value for BLDC Init Sequence 1,5ms
#define BLDC_PWM_INIT_HIGH_VALUE 330000

//Init Low value for BLDC Init Sequence 1,0ms
#define BLDC_PWM_INIT_LOW_VALUE 220000

//Stop Throttle value (N = 0rpm) below 1,1ms
#define BLDC_PWM_STOPTHROTTLE 240000

//fULL Throttle value (N = MAX rpm) 1,9ms
#define BLDC_PWM_FULLTHROTTLE 418000


void BLDC_Init(void);
void CTIMER3_Init(void);
void delay_ms(uint32_t value);
void BLDC_Init_Task(void *pvParameters);


#endif /* DRIVE_DRIVE_H_ */

servo.c

This file contains the timer initialization for the servo's PWM signal and a demo task

#include "servo.h"


const ctimer_config_t SERVO_config = {
		.mode = kCTIMER_TimerMode,   /* TC is incremented every rising APB bus clock edge */
		.input = kCTIMER_Capture_0,  /*!< Timer capture channel 0 */
		.prescale = 0                /*!< Prescale value 0 --> */
};

void SERVO_Init(void)
{

	CTIMER1_Init(); //Timer init function
	CTIMER1-> MCR 		|= CTIMER_MCR_MR2RL_MASK; 	//Reload MR2 with the contents of the shadow register when the timer counter (TC) is reset to 0
	IOCON->PIO[3][2]	&= 0xFFFFFFF0;      		//clear FUNC bits of P3.2
	IOCON->PIO[3][2]	|= 0x4;						//set FUNC bits to CTIMER1_MAT2 function ALT4 P3.2
	GPIO->DIR[3]        |= 1<<2;        			//set CTIMER1_MAT2 pin to output
	CTIMER1->MSR[2] = CTIMER1_PWM_PERIOD - SERVO_PWM_MiddleValue;
	if (xTaskCreate(SERVO_Demo, "SERVO_Demo", configMINIMAL_STACK_SIZE + 100, NULL, 1, NULL) !=
			pdPASS)
	{
		LED3_ON();
	}
}

void CTIMER1_Init(void)
{
	/* CTIMER1 peripheral initialization */
	CTIMER_Init(CTIMER1, &SERVO_config); //(CTIMER_Type, ctimer_config_t)
	/* PWM channel 2 of CTIMER1 peripheral initialization */
	CTIMER_SetupPwmPeriod(CTIMER1, CTIMER1_PWM_0_CHANNEL, CTIMER1_PWM_PERIOD, CTIMER1_PWM_0_DUTY, false); //(CTIMER_Type, ctimer_match_t,uint32_t,uint32_t)
	/* Start the timer */
	CTIMER_StartTimer(CTIMER1); //Timer starten
}

void SERVO_Demo(void *pvParameters)
{
	while(1)
	{
		//Steer left
		CTIMER1->MSR[2] = CTIMER1_PWM_PERIOD - SERVO_PWM_LeftValue;
		vTaskDelay(500);
		//Steer right
		CTIMER1->MSR[2] = CTIMER1_PWM_PERIOD - SERVO_PWM_RightValue;
		vTaskDelay(800);
		//Steering angle zero degree
		CTIMER1->MSR[2] = CTIMER1_PWM_PERIOD - SERVO_PWM_MiddleValue;
		vTaskSuspend(NULL);
	}
}

drive.c

This file contains the initialization of the vehicles drive. In addition to the timer initialization for the PWM signal, the startup sequence is also included.

/*
 * drive.c
 *
 *  Created on: 04.12.2020
 *      Author: Summer Matthias, Ecker Christian
 */


#include "drive.h"


const ctimer_config_t BLDC_config = {
		.mode = kCTIMER_TimerMode,   /* TC is incremented every rising APB bus clock edge */
		.input = kCTIMER_Capture_0,  /*!< Timer capture channel 0 */
		.prescale = 0                /*!< Prescale value 0 --> */
};

void BLDC_Init(void)
{

	CTIMER3_Init(); //Timer init function
	CTIMER3-> MCR 		|= CTIMER_MCR_MR0RL_MASK; 	//Reload MR0 with the contents of the shadow register when the timer counter (TC) is reset to 0
	IOCON->PIO[3][10]	&= 0xFFFFFFF0;      		//clear FUNC bits of P3.10
	IOCON->PIO[3][10]	|= 0x3;						//set FUNC bits to CTIMER3_MAT0 function ALT3 P3.10
	GPIO->DIR[3]        |= 1<<10;        			//set P3.10 to output
	//initalice MSR register with BLDC_INIT_LOW value (1.0 ms on time)
	CTIMER3->MSR[0] = CTIMER3_PWM_PERIOD - BLDC_PWM_INIT_LOW_VALUE;

	CTIMER3-> MCR 		|= CTIMER_MCR_MR2RL_MASK; 	//Reload MR2 with the contents of the shadow register when the timer counter (TC) is reset to 0
	IOCON->PIO[0][27]	&= 0xFFFFFFF0;      		//clear FUNC bits of P0.27
	IOCON->PIO[0][27]	|= 0x3;						//set FUNC bits to CTIMER3_MAT2 function ALT3 P0.27
	GPIO->DIR[0]        |= 1<<27;        			//set P0.27 to output
	//initalice MSR register with BLDC_INIT_LOW value (1.0 ms on time)
	CTIMER3->MSR[2] = CTIMER3_PWM_PERIOD - BLDC_PWM_INIT_LOW_VALUE;

	//crate initialication task for ESCs
	if (xTaskCreate(BLDC_Init_Task, "BLDC_Init_Task", configMINIMAL_STACK_SIZE + 100, NULL, 1, NULL) !=
			pdPASS)
	{
		LED3_ON();
	}
}

void CTIMER3_Init(void)
{
	/* CTIMER1 peripheral initialization */
	CTIMER_Init(CTIMER3, &BLDC_config); //(CTIMER_Type, ctimer_config_t)
	/* PWM channel 0 of CTIMER3 peripheral initialization */
	CTIMER_SetupPwmPeriod(CTIMER3, CTIMER3_PWM_LEFT_CHANNEL, CTIMER3_PWM_PERIOD, CTIMER3_PWM_0_DUTY, false); //(CTIMER_Type, ctimer_match_t,uint32_t,uint32_t)
	/* PWM channel 2 of CTIMER3 peripheral initialization */
	CTIMER_SetupPwmPeriod(CTIMER3, CTIMER3_PWM_RIGHT_CHANNEL, CTIMER3_PWM_PERIOD, CTIMER3_PWM_0_DUTY, false); //(CTIMER_Type, ctimer_match_t,uint32_t,uint32_t)

	/* Start the timer */
	CTIMER_StartTimer(CTIMER3); //Timer starten
}

//Initialize ESCs
void BLDC_Init_Task(void *pvParameters)
{
	while(1){

		//Initialize Sequence for BLDC-Motors
		//low throttle value
		CTIMER3->MSR[0] = CTIMER3_PWM_PERIOD - BLDC_PWM_INIT_LOW_VALUE;
		CTIMER3->MSR[2] = CTIMER3_PWM_PERIOD - BLDC_PWM_INIT_LOW_VALUE;
		vTaskDelay(2000);
		//half throttle value
		CTIMER3->MSR[0] = CTIMER3_PWM_PERIOD - BLDC_PWM_INIT_HIGH_VALUE;
		CTIMER3->MSR[2] = CTIMER3_PWM_PERIOD - BLDC_PWM_INIT_HIGH_VALUE;
		vTaskDelay(2000);
		//low throttle value
		CTIMER3->MSR[0] = CTIMER3_PWM_PERIOD - BLDC_PWM_INIT_LOW_VALUE;
		CTIMER3->MSR[2] = CTIMER3_PWM_PERIOD - BLDC_PWM_INIT_LOW_VALUE;
		vTaskDelay(3500);
      
		//suspend Task
		vTaskSuspend(NULL);
	}
}

Shop

Community

Learn

Blog

Shop home

3D printing

Single Board Computers

Development kits

Sensors

Internet of things

Robotics

Accessories

Upload project

Projects

Discord

Electromaker kits

Tutorials

Electromaker Educator

Latest

ElectroWire - News

Featured

Reviews