Difference between revisions of "F15: Undergrads++"

Latest revision as of 20:39, 19 December 2015

Undergrads++

Undergrads++ Car

Under the hood

Abstract

The project is an autonomous car that shall avoid obstacles. The car will consist of five SJ One controllers connected and communicating via one operational CAN bus. Each controller shall be handled by teams of two people per component and integrated to 1 working autonomous car. The Master Controller team shall be responsible for collecting data from the other controllers and guiding the car using high-level logic. The Motor I/O Controller team shall be responsible for the operation of the motors and operation of the LCD display, which will display debugging or current status messages. The Sensor Controller team shall be responsible for collecting data from the sonar sensors and sending the appropriate data. The Geographical Controller team shall be responsible for calculating the orientation of the car as well as the current position in relation to it's desired destination. The Bluetooth/Bridge Controller team shall be responsible for the interface to the end user and sending the way-points. All of these five devices shall operate simultaneously and reach the requested destination.

Objectives & Introduction

• The user shall be able to set a longitude/latitude using an Android app
• The user shall be able to send a Start command to start the navigation routine
• The car shall avoid obstacles and navigate appropriately around them
• The car shall contain sensors in the front and back to go forward and backward without intervention
• The car shall reach the destination before the battery dies
• The car shall contain a GPS and compass to calculate the heading, longitude, and latitude
• The car shall contain a Bluetooth device to receive information from the Android App
• The car shall contain appropriate sensors to internally calculate the speed of the car
• The car shall be able to adjust it's speed appropriately when commanded by the Master controller
• The car shall display appropriate information on the LCD display

System Communication Overview

Team Members & Responsibilities

Master Controller

• Marvin Flores
• Hassan Naveed

Sensor Controller & Finances

• Arlen Eskandari
• Onyema Ude

GPS Controller & iCAN API

• Calvin Lai
• Jonathon Hongpananon

Motor/LCD Controller

• Hector Prado-Guerrero
• Jashan Singh

Bridge/Android Controller

• Phil Tran
• Shangming Wang

Parts List & Cost

This section goes over the parts that we ordered and the cost of each item.

Design & Implementation

The section goes over our top-level designs of our project.

CAN Message ID Table

CAN Interface and Power Supply Hardware

To connect all 5 boards together via CAN bus, five SN65HVD230 CAN transceivers are placed on a prototype board. Furthermore for the 5V power supply needed, a portable power bank is used and the power is distributed using the same prototype board the CAN transceivers uses (figures below).

CAN Interface and Power Supply

CAN Interface and Power Supply prototype

DBC File Implementation

Throughout the development and life-cycle of our project we used a DBC file and a python parser to generate C-code for the five controllers. The DBC file contained CAN messages organized in a particular format, which the python parser generated appropriate code for each CAN node. The C-code generated contained inline functions to convert messages to and from raw CAN messages using marshal and unmarshal operations. This provided a centralized CAN message base for all of the teams to use so that there was consistency throughout the project.

• The DBC file :

 VERSION ""
  
 
 NS_ : 
 	NS_DESC_
 	CM_
 	BA_DEF_
 	BA_
 	VAL_
 	CAT_DEF_
 	CAT_
 	FILTER
 	BA_DEF_DEF_
 	EV_DATA_
 	ENVVAR_DATA_
 	SGTYPE_
 	SGTYPE_VAL_
 	BA_DEF_SGTYPE_
 	BA_SGTYPE_
 	SIG_TYPE_REF_
 	VAL_TABLE_
 	SIG_GROUP_
 	SIG_VALTYPE_
 	SIGTYPE_VALTYPE_
 	BO_TX_BU_
 	BA_DEF_REL_
 	BA_REL_
 	BA_DEF_DEF_REL_
 	BU_SG_REL_
 	BU_EV_REL_
 	BU_BO_REL_
 	SG_MUL_VAL_
 
 BS_:
 
 BU_: NOONE SENSOR MASTER MOTOR GPS ANDROID
 
 BO_ 100 HEARTBEAT: 1 MASTER
  SG_ MASTER_HEARTBEAT_cmd : 0|8@1+ (1,0) [0|0] "" SENSOR,MOTOR
 
 BO_ 600 INFO_SONARS: 4 SENSOR
  SG_ SENSOR_INFO_SONARS_left : 0|8@1+ (1,0) [0|255] "inch" MASTER
  SG_ SENSOR_INFO_SONARS_middle : 8|8@1+ (1,0) [0|255] "inch" MASTER
  SG_ SENSOR_INFO_SONARS_right : 16|8@1+ (1,0) [0|255] "inch" MASTER
  SG_ SENSOR_INFO_SONARS_rear : 24|8@1+ (1,0) [0|255] "inch" MASTER
 
 BO_ 604 MOTOR_CMD: 2 MASTER
  SG_ MASTER_MOTOR_CMD_steer : 0|8@1+ (1,0) [0|20] "" MOTOR
  SG_ MASTER_MOTOR_CMD_drive : 8|8@1+ (1,0) [0|20] "" MOTOR
 
 BO_ 700 STOP_GO_CMD: 1 ANDROID
  SG_ ANDROID_STOP_CMD_signal : 0|8@1+ (1,0) [0|0] "" MASTER,GPS
 
 BO_ 708 INFO_CHECKPOINTS: 1 ANDROID
  SG_ ANDROID_INFO_CHECKPOINTS_count : 0|8@1+ (1,0) [0|255] "" MASTER,GPS 
 
 BO_ 712 INFO_COORDINATES: 8 ANDROID
  SG_ GPS_INFO_COORDINATES_lat : 0|32@1+ (0.00001,0) [0|0] "" MASTER,GPS
  SG_ GPS_INFO_COORDINATES_long : 32|32@1+ (0.00001,0) [0|0] "" MASTER,GPS
 
 BO_ 716 INFO_HEADING: 4 GPS
  SG_ GPS_INFO_HEADING_current : 0|16@1- (1,0) [0|0] "" MASTER
  SG_ GPS_INFO_HEADING_dst : 16|16@1- (1,0) [0|0] "" MASTER
 
 BO_ 720 DESTINATION_REACHED: 1 GPS
  SG_ GPS_DESTINATION_REACHED_signal : 0|8@1+ (1,0) [0|0] "" MASTER,ANDROID
 
 CM_ BU_ NOONE "No node, used to indicate if it's a debug message going to no one";
 CM_ BU_ MASTER "The driver controller driving the car";
CM_ BU_ SENSOR "The sensor controller of the car";
 CM_ BU_ MOTOR "The motor controller of the car";
 CM_ BU_ ANDROID "The android controller of the car";
 CM_ BO_ 100 "Sync message used to synchronize the controllers";
 
 BA_DEF_  "BusType" STRING ;
 BA_DEF_ SG_ "FieldType" STRING ;
 BA_DEF_ BO_ "GenMsgCycleTime" INT 0 0;
 
 BA_DEF_DEF_ "BusType" "CAN";
 BA_DEF_DEF_ "FieldType" ""; 
 
 BA_ "GenMsgCycleTime" BO_ 100 1000;
 BA_ "GenMsgCycleTime" BO_ 200 100;
 BA_ "GenMsgCycleTime" BO_ 300 100;
 BA_ "FieldType" SG_ 100 MASTER_HEARTBEAT_cmd "MASTER_HEARTBEAT_cmd" 
 BA_ "FieldType" SG_ 604 MASTER_MOTOR_CMD_drive "MASTER_MOTOR_CMD_drive"
 BA_ "FieldType" SG_ 604 MASTER_MOTOR_CMD_steer "MASTER_MOTOR_CMD_steer"
 
 VAL_ 100 MASTER_HEARTBEAT_cmd 0 "MASTER_HEARTBEAT_cmd_NOOP" 1 "MASTER_HEARTBEAT_cmd_SYNC" 2 "MASTER_HEARTBEAT_cmd_REBOOT" ;
 VAL_ 604 MASTER_MOTOR_CMD_drive 4 "MASTER_MOTOR_CMD_drive_FAST" 3 "MASTER_MOTOR_CMD_drive_MEDIUM" 2 "MASTER_MOTOR_CMD_drive_SLOW" 1 "MASTER_MOTOR_CMD_drive_REVERSE" 0 "MASTER_MOTOR_CMD_drive_STOP" ;
 VAL_ 604 MASTER_MOTOR_CMD_steer 4 "MASTER_MOTOR_CMD_steer_HARD_RIGHT" 3 "MASTER_MOTOR_CMD_steer_SOFT_RIGHT" 2 "MASTER_MOTOR_CMD_steer_STRAIGHT" 1 "MASTER_MOTOR_CMD_steer_SOFT_LEFT" 0 "MASTER_MOTOR_CMD_steer_HARD_LEFT"   ;
 

Git Submodule Add-on

To increase productivity and be more organized through the life-cycle of this project, our team implemented and used a git submodule. A git submodule is a separate Git repository, which is a subdirectory of our entire main Git repository. This allows us to clone another repository within our project and keep commit history of this submodule separate from the separated projects. The Git submodule allowed a central repository to be used for common code such as the DBC file, python parser, and other source/header files we shared. Due to the fact that every team had a separate branch they were working on (for each controller), there was no way to share code throughout each of the different groups. The submodule made code accessible to all teams instead of manually making changes when necessary. For example, if 1 team made a change to a file, then the other 4 teams already have the recent change without having to manually update. The update is automatic to everyone who has the Git submodule set up.

• To set up a git submodule you can perform the following instructions:
  • Create your separate repository on GitLab.com or GitHub.com, whichever Git repository you prefer to use.
  • Execute : git submodule add ssh_url relative_path_to_new_dir
  • Execute : git status
  • Notice a new change to be commited. There should be a .gitmodule created. This contains details supplied about the new submodule.
  • Execute : git submodule init
  • Execute : git submodule update
• To use the git submodule you just 'cd' into the directory where the git submodule repo is located, and treat it as an independent Git project. There is a master branch you can checkout and pull from to pull-in the most recent changes. Make commits and push like you would to any other Git project. When there are changes made to this Git submodule then there will be new changes shown in the top project directory. You will want to add this change to your next commit so that your top project points to the correct Git submodule commit number.

Full CAN Implementation

Our project uses the Full CAN available on the LPC1758. This method of interfacing with the CAN bus allows the microcontroller to use hardware based CAN message filtering as opposed to software based filtering. Message IDs are added to the acceptance list during the CAN initialization stage where they will each be allocated a space in memory used to store a pointer to messages. During runtime accepted messages will be placed directly into RAM and the reference pointer to this message will be stored in the previously allocated space. Since messages are automatically placed in RAM, there is no longer a need to poll the CAN bus or set a timeout for waiting on messages to arrive. We can now check for new messages whenever we feel that fresh information is required.

The use of the Full CAN is similar to that of the regular CAN save for two points.

• During initialization accepted message ids must be added to the acceptance filter using the CAN_fullcan_add_entry() function found in the provided CAN api.
• Messages are retrieved using the CAN_fullcan_get_entry_ptr() function found in the provided CAN api. This function will return a pointer to a can_fullcan_msg_t found in memory.

Wrapper functions were created in order to simplify the initialization, sending and receiving of messages through the Full CAN api.

 bool iCAN_init_FULLCAN(uint32_t * std_list_arr, size_t arraySize); // std_list_arr is an array of accepted message IDs.
 bool iCAN_rx(can_fullcan_msg_t *msg, msg_hdr_t *msg_hdr);
 bool iCAN_tx(can_msg_t *msg, msg_hdr_t *msg_hdr);

Master Controller

Master Controller

• Marvin Flores
• Hassan Naveed

Master Controller Team Schedule

Hardware Design

For the master controller, hardware part essentially covers setting up the CAN bus. The master controller communicates with all other controllers on board i.e the motor, android, GPS, compass and sensors. The bus was set up using five SN65HVD233-HT 3.3-V CAN transceiver chips to send and receive CAN messages from the master controller.

SN65HVD233-HT 3.3-V CAN transceiver

Hardware Interface

The RD1 (pin 0.0) and TD1 (pin 0.1) on the SJ ONE board are connected to the CAN RECEIVE data output and CAN TRANSMIT data input pins on the CAN transceiver. A 120 ohm resistor is attached as a termination resistor between CANH and CANL pins of the two transceivers. This ensures that a transmitting node does not get its own reflection. For the software part, we configured the CAN bus using the FULL CAN mode. The main advantage of using the FULL CAN is that the processor does not have to parse the incoming message and messages go inside designated mail boxes. To initialize the CAN bus in FULL CAN mode, we set its baud rate to be 100kbps, the receive and send queue size to be 50 and pass an array of accepted message IDs and its size as parameters to the following function which initializes the CAN BUS.

bool iCAN_init_FULLCAN(uint32_t * std_list_arr, size_t arraySize);

The function returns true if the bus is initialized successfully and all the message IDs are added to the acceptance filter.

These messages can then be read using a pointer to the message mailbox as the first parameter and the dbc decode function as the second parameter to the following function:

iCAN_rx(can_fullcan_msg_t *msg, msg_hdr_t *msg_hdr);

For sending, after the DBC file encodes the message, we can transmit it over the CAN bus using the transmit function. First parameter is a pointer to the can_msg_t message and the second is the pointer to the message header generated by dbc parser.

bool iCAN_tx(can_msg_t *msg, msg_hdr_t *msg_hdr);

Software Design

Motor Control Logic

The software design is based on layered architecture. There are a total of three layers and they are listed below:

• Communication layer - responsible for receiving CAN messages
• Data layer - responsible for extracting or encoding the data from CAN messages
• Control layer - responsible for making decisions based on data processing and controlling the overall behavior of the car.

All layers are being done in the 100Hz task. First, the Communication layer handles all the incoming messages sent to the MASTER CONTROLLER (i.e. Heading values, STOP/GO Signal, Sensor values, and Destination reached signal). All values are saved in their respective global variables.

Next, The data layer parses the values in the following order:

1.) Check whether we have a STOP/GO signal or Destination reached signal.

2.) Parse the sensor values; comparing them to their minimum block values.

3.) Generate motor commands based on the parsed sensor values if the car is about to hit an object.

4.) Parse the destination and current heading sent by the GPS controller and set car steering direction accordingly.

5.) Send motor commands.

The idea is to run everything in one pass (within the 100Hz task) for logic simplicity. The image above shows the high level view of our driving logic based on the sensor and heading values. The Image below shows the minimum block values of the sensors. When one of the sensors reads a value lower than its minimum block value, appropriate action is taken.

Sensor minimum block values

The GPS controller keeps on sending the next checkpoint to the master each time it reaches the current one. After the master receives and reaches the final checkpoint, the GPS controller sets a flag final_destination_reached and the master responds by resetting the GO signal and commanding the motors to stop.

The master controller also makes the decision to turn the car left or right or go straight to reach the destination. This decision is made based on two values:

• Current bearing
• Destination bearing

The algorithm was developed keeping two things in focus:

1) The car should follow a straight line as long as its current bearing is in X degrees(depending on the precision) of the destination bearing.

2) If the destination heading differs from the current heading from more than X degrees, turn left or right, depending upon which would be a shorter turn to maintain the destination heading.

Current vs Destination bearing

We used a tolerance level of 20 degrees (the X value). This ensured that the car is not turning left or right all the time and stays steady without ever being too out of sync from the destination heading. As long as the car is within 20 degrees of the destination heading, it maintains its course. This is still very accurate because as the car gets closer to destination, the destination heading changes drastically allowing the car to zero in on the actual destination.

Motor I/O Controller

Motor/LCD Controller

• Hector Prado-Guerrero
• Jashan Singh

Motor control/LCD Team Schedule

Hardware Design

For the hardware aspect of the Motor/IO group, there were four modules that needed to be designed, and integrated: ESC/DC motor, Servo motor, LCD, and wheel encoder. The ESC/DC motor module is what controls the speed of the car; Servo motor controls the steering of the car; LCD displays important information about the status of the car; wheel encoder dynamically adjusts car speed based off of a reference speed in case the car's battery starts to die, or the car begins going uphill, for example.

SJSU One board -> Peripherals

Parts and Description

Velineon VXL-3s ESC

ESC : The kit for the car included the VXL-3s electronic speed controller (ESC) for motor control. Most of the motor/LCD team’s time was spent interfacing the ESC with the software. The ESC required a very intricate initialization of its subprofiles to operate properly. This initialization process involved sending sequential PWM signals to the ESC before signals could be sent to the motor. Once figuring out the proper initialization process, we were able to get control of the motor. The ESC was initialized to a 100 hz PWM communication frequency, and after several testing sessions we found out that a 15.75%, 15% and 13.75% duty cycle was required for forward, neutral and reverse, respectively.

Traxxas 3785 Titan 12 Turn 550 Motor

Motor : The car kit also included the Velineon 3500 Brushless Motor. Since this motor was a brushless motor, it required a very specific range of PWM signals to operate. For our purposes, we required low to medium speed range for the motor. However, we soon found out that this motor would not serve us for that purpose because it is almost impossible for it to go slow as it is made to go at higher speed which was unbeknownst to us. To mitigate this, the Traxxas 3785 Titan 12 Turn 550 brushed motor was used. Since this motor was brushed, we were able to get the car moving at medium to very low speeds which enabled us to make proper turning maneuvers.

Traxxas Servo

Servo : The kit came with a servo motor for turning left and right. The gear ratio for this servo allowed for high torque output with 180 degree end stops. For the purposes of this project we only required the servo to turn approximately 90 degrees for full mobility of the steering.

LCD Mounted on Car

LCD : The LCD used for the Undergrads++ car was provided by Preet. This particular LCD did not have any manufacturer name on it and because of this it was a bit difficult to find any documentation for it. We were able to figure out that the screen was 4 row by 20 columns which served well for our purposes. A driver module was also provided with the LCD which enabled communication over UART. Luckily, we were able to find commands for the LCD from the wikipedia report page of a previous team who used a similar LCD. To display data to the LCD we sent these commands over UART along with slight delays so that the LCD would have ample time to respond. We had the following information displayed on the screen: steering, speed, current heading and destination heading as well as front, left, right and rear distance sensor values.

Lithium Iron Phosphate Battery (LiFePO4)

Battery: After it was learned that the supplied battery with the car kit would not suffice, we decided to get a new battery to reduce the voltage input to the motor in hopes that it would help in slowing it down. After much research, we ordered the Turnigy nano-tech 3000mAh 6.6V LiFePO4 battery. The characteristics of this lithium iron phosphate battery make it very ideal for this project. LiFePO batteries are very resilient to quick discharges and hold up very well to shock or puncturing as compared to the common lithium polymer batteries.

Hardware Interface

For the overall communication of the car, CAN bus was used for interfacing. However, interfacing to the motor electronic speed controller (ESC), and servo were controlled with the use of Pulse Width Modulation signals (PWM). The ESC uses values ranging from 1ms to 2ms, with 1.5ms being "neutral". The LCD need to receive commands via Universal Asynchronous Receiver/Transmitter (UART) bus. Lastly, the motor encoder used a basic GPIO pin from the SJSU one microcontroller to connect to the encoder's output pin.

Motor Mounted on Car

Motor For the motor, it was necessary to create an ESC programming function in which the provided datasheet for the ESC states that the ESC needs to receive the range of values for forward trigger, and reverse trigger and neutral. This equates to the function sending Neutral, then sending incremental values from neutral up to the max duty cycle, of 20% at 100Hz. Then, the same goes for reverse, one starts at sneding it neutral, then decrements all the way down to a 10% duty cycle. After the ESC is programmed properly for the associated PWM cycle, all that's left is making sure there's at least a 10-20ms delay between each motor control command so that the ESC has enough time to register the receiving commands. From here on out, you can simply sending it any range about about 15.4% duty cycle to the max of 20% duty cycle. Same goes for reverse. MAKE SURE ALL GROUNDS ARE CONNECTED (i.e. ground from power source to a common bus as the microcontroller).

Servo Just as the motor needs PWM, the servo does as well. Luckily for us, the servo used the same period 1ms, 1.5ms, and 2ms, which allowed for almost 100% code reuse for controlling the servo. The good part about the servo is that there is no need to initialize, just make sure it has a proper power source, and ALL GROUNDS ARE CONNECTED (i.e. ground from power source to a common bus as the microcontroller) or else it won't work.

LCD For the LCD, the baud rate was set automatically. There was, however, an initial command to be sent through UART to initialize the LCD. After that, the LCD can be manipulated using the commands, and sending it the data that you want it to display, with well formatting. Note: Make sure that the board and LCD are powered at the same time; yes that means unplugging it from your laptop USB, and powering the LCD and then plugging your SJOne board back in.

Encoder Mounted on Car

Encoder Encoder uses a basic output pin that outputs HIGH for detecting a white line, and a LOW signal for everything else. It was very simple to interface with the microcontroller, as one can simply use a GPIO pin to listen for the HIGH signal, and just set off an interrupt such that there's no delay. For calculating the speed, there first needed to be field testing for a nominal value; this nominal value then becomes the reference point for which you do your calculating. Because the encoder was being triggered five times, we were calculating the time between each tick mark, and seeing if they deviated more than 5-10% from one tick set, to the other. This ensured we get accurate readings of the speed. If the time went outside of the threshold range, the speed of the car would be incremented by a small amount, to try and match the nominal value's speed. Again, make sure ALL GROUNDS ARE CONNECTED.

Software Design

For software, the motor and servo controls, were all being called through a real-time scheduler that uses periodic scheduled call back functions: 1Hz, 10Hz, 100Hz, and 1000Hz. The premise, however, is that these functions are strictly timed, and thus, are programmed to crash the board if your code happens to run past it's dedicated time slot. The use of this real-time scheduler has helped us gain a lot of insight into the application, and uses, of a real-time scheduler.

Motor/Servo Flow

Motor/Servo commands

LCD Flow

LCD Commands

LCD Commands The following table shows the commands sent to the LCD over the UART bus. At startup, 0xF0 is sent to the LCD which initializes it to 9600 baud rate. The LCD then waits for any additionally commands to be sent for processing and display. The commands were sent using the 'putline()' and 'putchar()' functions which are built into the UART API. We interfaced the LCD's 'Blight' command for the purposes of alerting if the car's CAN bus is inactive or off. When the bus is off, the LCD LED backlight flashes between 100 and 20 percent.

Encoder Flow

Encoder Commands

Sensor Controller

Sensor Controller & Finances

• Arlen Eskandari
• Onyema Ude

Sensor Controller Team Schedule

Hardware Design

4 LV-MaxSonar sensors are used for the project, they are used for obstacle detection and avoidance. These sensors are able to detect obstacles 0 – 254 inches, though objects 6 inches or closer are simply registered as 6 inches. Sensors are powered with 5Volts (3.3Volts option is also available). Each reading takes 50ms, and each sensor is enabled at a time using the RX pin on it to avoid crosstalk. Three sensors are placed in front of the car (Left , Middle, Right) and one at the back. The image below shows the wired connections between sensors and SJOne board, and the one on the right shows the mounted sensors.

Sensor Hardware Design

Mounted Senors

Software Design

In this project the "PWM" option of the sonar sensor is used to measure the distance. 250ms after power up the sensors are ready to take their first measurement, the very first measurement takes 98ms (an additional 49ms for initial calibration) and the consecutive measurements take 49ms each.

The software starts the measurement in order of Left, middle, right, and rear (Figure A). To start the measurement the RX pin of the sensor (which is connected to a dedicated GPIO pin separately for each sensor) is set high for 50ms (49ms is the minimum), at the moment the software saves the system clock uptime in a variable "trig_time" (Figure B). As soon as sensor is enabled, it sends out an ultrasonic burst, then the moment sensors receives the bounced back signal from an obstacle the "PW" pin of the sensor which is connected to an "interrupt enabled" (falling edge) GPIO pin is set low (Figure C). The moment the Interrupt enabled GPIO pin goes low, the interrupt service routine goes to "calculate_dist" function to calculate the distance by first subtracting the current system uptime from "trig_time" which was saved before; then dividing it by 174 (given by datasheet) to measure the distance in inches (figure D).

Immediately measuring the next sensor after the current sensor measurement is done gives inconsistent measurements. Adding some delay (50ms in this case) between each measurement solves this problem.

The Range() function (figure A) is called 4 times in the 1Hz periodic function which gives 4 samples from each sensor every second. Each round of ranging takes about 250ms (50ms for each sensor plus the delays) so the Range() function would outrun even the 10Hz periodic function so it could not be placed there and had to be put in the 1Hz function.

After the left sensor finished its measurement, the RX pin on the left sensor is pulled low to disable the sensor, then the RX pin of the middle sensor is pulled high to enable the sensor (at this moment all other sensors are disabled except the middle one to eliminate crosstalk). Then after enabling the middle sensor all the ranging procedure is identical to the one explained above. For the right, and rear sensors the same procedure is repeated all over.

After all the sensors have been saved in separate variables, the variables are packed and sent to "CAN_send" function to be sent to the Master via CAN bus.

void Range()
{
    Range_left();
    delay_ms(50);
    Range_middle();
    delay_ms(50);
    Range_right();
    delay_ms(50);
    Range_rear();
    delay_ms(50);
    CAN_send();
    test();
}

Figure A. Sensor Ranging order

void Range_left(void)
{
    Left_en.setHigh(); // enable Ranging   (enable left sonar)
    delay_us(21); //hold high  >20uS to enable ranging
    Left_trig_time = sys_get_uptime_us(); //get timer at the moment ranging starts
    Left_en.setLow(); // disable ranging of left sonar
}

Figure B. Enabling Sensor and saving the system uptime

 eint3_enable_port2(2, eint_falling_edge, calc_dist_middle); //Middle Sonar

Figure C. Enabling the interrupt for GPIO pin2.2

   void calc_dist_left(void)
{
   left_dist = ((sys_get_uptime_us() - Left_trig_time)/147) ; //each 147uS is 1 inch (Datasheet)
}

Figure D. Function called by the interrupt to calculate the distance

Bluetooth/Bridge Controller

Bridge/Android Controller

• Phil Tran
• Shangming Wang

Android/Bluetooth Team Schedule

Hardware Design

The Bridge communication hardware design is very simple. A BTBEE Pro Bluetooth XBee socket chip is connected to the SJOne board. UART2 port on the SJOne board is used. UART2 Rx and Tx from the pins on the board are connected to the CAN Bus, which is then connected onto the CAN wires.

Android Hardware Design

Hardware Interface

Overall, the interface between Android and the SJOne board is simple. The Bluetooth module (BTBee Pro) is connected to XBEE port on the SJOne board. The UART2 switch is flipped so that the BTBee could accept UART2 line information. The Android writes to the BTBee at 115200 bps. The BTBee then sends the information to the SJOne board through UART2 through a command line. The data is then encoded to fit the CAN bus. Any other CAN transceiver can listen to the message it sends. The RD1 and TD1 pins are connected to the Tx and Rx pins of the CAN Transceiver. The Bridge SJOne board will then properly shift bits into the data field of the CAN bus and transmit it using Full CAN. GPS and Master are continuously listening for messages sent by the Bridge Controller. The checkpoint is the counter that keeps track of the current total coordinates received. At endread, the checkpoint is reset back to 0 so that it can prepare for the next set of coordinates. The flow chart shown below illustrates how the Bridge controller receives coordinates from Android and how it processes in the command terminal.

Android Software Design

Software Design

The Android program was written with the Android SDK. The program uses one Activity and three fragments under that Activity (as seen in the Visio diagram). The Activity is the base of the program, and it manages the three fragments in it using a FragmentTransaction and FragmentManager class. There is another layout in the Activity's layout that is specifically made as a fragment container. The Activity features three buttons at the bottom of the screen. Each button with show a fragment. All fragments are constantly running, and the Activity simply hides fragments from the user when the user clicks on a button in the bottom menu. Fragments communicate with each other by using the Activity as a middle man. Information from Fragment A can pass its information to Fragment B by first going through Activity.

Fragment Layout under Activity

Fragment Layout under Activity

Google Maps was inserted into the Maps Fragment. An API key was needed in order for Google Maps to work on the phone. An open source API was used to get the directions and and coordinates of the start and end position. A LatLng list array was inserted to the API to get the list of coordinates. After choosing a point, the "SET" button should be pressed, and the array will be transmitted through bluetooth. The Maps Fragment features buttons that allow operation of the vehicle. These buttons will transmit data to the SJOne board through Bluetooth. All data from Android must first be converted to string and then converted to a byte array in order to be sent over Bluetooth

The Bluetooth API was used to send data from the Android to the SJOne board. When transmitting data from Android to SJOne, a terminal command is used on the SJOne board side to receive data. This is done by using the UART2 ports of the board, and connecting it with a Bluetooth transceiver.

The Bluetooth communication is sent using the write function on Android. Each write function takes a command that the terminal command one the SJOne board will receive. At every command, an action happens. Every command takes a format:

On the SJOne board side, all the operations on the CAN bus happen on the 100Hz Periodic Callback. The flags dictate the flow of transmission of checkpoints. Only when the flags are true will transmission happen. The GO and STOP commands are also set by flags.

Video of the application. Android Application in Action

Geographical Controller

The Geographical Controller is responsible for providing the location of the car and heading direction to the master controller. It receives the way-points from the Bridge Controller and calculates the distance to the final destination. The Master Controller is still responsible for controlling the logic of forward, backward, left, and right to reach the final destination.

GPS Controller

• Calvin Lai
• Jonathon Hongpananon

GPS Controller Team Schedule

Hardware Design

The figure below illustrates the high-level design for the Geographical Controller. The Geographical controller uses an Adafruit GPS Breakout and an Adafruit 10 Degrees Of Freedom (DOF) IMU Breakout. The Adafruit GPS breakout is a GPS module with a 10Hz update rate with a low current draw, which makes this an excellent device for low power consumption. The Adafruit 10-DOF IMU Breakout contains an accelerometer, gyroscope, magnetometer, barometer, and temperature sensor; however, only the magnetometer was used to calculate the heading direction.

Geographical Hardware Design

Hardware Interface

Software Design

GPS Data Format

The following table below shows the type of information that is retrieved from the Adafruit GPS chip. When interfaced with the GPS via UART, the string that is received is in the format

$GPGGA,hhmmss.ss,llll.ll,a,yyyyy.yy,a,x,xx,x.x,x.x,M,x.x,M,x.x,xxxx*hh.

The Geographical Controller is responsible for parsing this information and handling the data appropriately.

After parsing the NMEA string, the correct heading must be calculated to help orient the car in the correct direction. When the correct heading is calculated, the current and correct heading are both sent in a single CAN message to the master controller.

Tasks

Algorithms Used

Finding the correct heading between two geographical coordinates.

  correctHeading = atan2(dy, dx) * 180 / pi; (where dy and dx are the delta of latitude and longitude)

Finding the distance between two geographical coordinates.

   dist = sin(degreeToRadian(lat1)) * sin(degreeToRadian(lat2)) + cos(degreeToRadian(lat1)) * cos(degreeToRadian(lat2)) * cos(degreeToRadian(theta));
   dist = acos(dist);
   dist = radianToDegree(dist);
   dist = dist * 60 * 1.1515 * 1.609344;

Testing & Technical Challenges

Problems Encountered

Conclusion

Self driving cars are the next step that humans as a civilization are taking in the advancement of science and technology and this project is a tiny effort in that area. The project ran almost the entire length of the semester and we as a team learnt a lot from it. Although the main focus of the class lectures were about CAN Bus, basic communication protocols, FreeRTOS and programming paradigms, we had to do much more learning outside of the classroom. We came across really complex hardware and software problems like noise, signal integrity and signal conditioning cannot be solved by software or hardware alone. It takes a combination of the two to solve it. This project also developed our skills to work in teams and collaborate together over a long period of time. Communication is key to finishing a project of this scale. In order for this project to work, every sub-team must come together to integrate separate modules and making them work.

Project Video

Android Application in Action

CMPE 243 Car Test Run

CMPE 243 Car Test Run Second Angle

Project Source Code

• Sourceforge Source Code Link
• GitLab Source Code Link
• Git Submodule Source Code Link

References

Acknowledgement

The team would like to thank Preet for giving us the foundation for the team work on as well as showing us programming techniques and communication protocols. We would like to thank Mr. Leepeng, our team advisor and the other Autocar teams for trading knowledge and having discussions on what to do better.

References Used

http://www.freertos.org

Official Android API Guide

http://www.nxp.com/documents/user_manual/UM10360.pdf

http://www.socialledge.com/sjsu/index.php?title=SJ_One_Board