Difference between revisions of "Self-driving Car"

Revision as of 23:10, 23 September 2015

This project is about a large team getting a car to self-drive to a selected destination. This involves working with an RTOS running on a low power processor and various different processor boards working together over a CAN bus.

Contents 1 Gitlab 2 Schedule 3 Parts 4 Controllers 5 Communication 5.1 Recommended CAN Message ID format 5.2 Example Controller Communication Table 6 How will communication work? 7 Features 7.1 Quick and Easy Features 7.2 Robustness 7.3 Startup Tests 7.3.1 Considerations 8 Grade 9 Sample Code 9.1 Part 1: Basic structure and CAN initialization 9.2 Part 2: Periodic Parsing Task

Gitlab

Create a "master" Gitlab project that contains sub-folders of each project. Please provide me the access (username: preet) to your master project so I can peek at all of your source code when needed. The Gitlab will track your commit history so I would also know how much work each person or team is contributing.

The folder structure should be:

• TeamX_CmpE_Fall2015

  Sensor

  IO

  <other controller projects>

Schedule

Parts

• DfRobot
• Parts + Useful links

Controllers

Given below are the controllers, their duties, and the number of people involved. It is possible that one team gets done with their part, but that doesn't mean your job is done. If you are done, help others. If you are done, and the primary objective is met (the car can self-drive), then add more features. There are many things you can do, and the 16-week semester definitely won't provide an opportunity to sit and relax. Get up and learn!.

Communication

Each controller shall provide a means to communicate with the other controllers. Before you read any further, it requires that you have deep knowledge of the CAN bus. CAN is a BROADCAST communication bus, but in our software we can add addressing such that we can have 1:1 communication (rather than 1:many). Each controller shall pick a controller number. The controller with the highest priority shall pick the lowest ID. Using this protocol, each controller can specifically send a message to any other controller, and likewise, upon a received message, we can tell who it came from.

Recommended CAN Message ID format

We split the 29-bit CAN message ID into 3 portions to support peer-to-peer communication. When a CAN message arrives, we will have its 29-bit ID, and out of this, we can determine who sent it, and what message number they sent.

You should configure your CAN hardware filter based on your controller ID. So if your controller is ID 0x50, you should accept all messages in this range: 0x50.00.000 - 0x50.FF.FFF. In particular, your CAN hardware filter needs a single EXTENDED GROUP filter.

You should use 0xFF as a "BROADCAST" address. So if a node sends a message with destination address 0xFF and message number is 0x101, then ALL controllers should respond to this command. So this means you need another acceptance filter with this range: 0xFF.00.000 - 0xFF.FF.FFF

Example Controller Communication Table

byte [0-3] : System time

byte [0-3] : Version Info
byte [4-7] : boot timestamp

byte [0-3] : Current time
byte [4]   : CPU usage %

byte [0-3] : (float) Longitude
byte [4-7] : (float) Latitude

byte [0-3] : (float) Longitude
byte [4-7] : (float) Latitude

byte [0-1] : (uint16) Current compass degree
byte [2-3] : (uint16) Destination compass degree

byte [0] : Front sensor value in inches
byte [1] : Left sensor value in inches
byte [2] : Right sensor value in inches
etc.

How will communication work?

After startup, begin to send your data messages at the desired periodic rates using the periodic API as listed below in the example. Whichever controller wants to listen to your periodic message shall intercept your message and use it for its needs.

You can have global variables for the CAN data messages, and tasks should update the data within these messages. Assuming that you've added periodic message to be sent to broadcast address (0xFF), the periodic tasks will always grab the latest CAN message and send it out for you.

Features

The first feature to develop is the self-drive capability and everything else comes later. While some people in the team may be focusing on delivering this primary feature, other members can focus on other things such as automatic headlights, variable speed settings through Android interface etc. If your product team fails, then just like it would happen in the industry, you will get laid off, and I will see you again in the course ;(

Quick and Easy Features

These features are mandatory, just to help you debug faster.

• Each controller shall display its version information at startup, for example:

  "Version 1.2"

  "Fixed rear sensor reporting zero value"

  "Version 1.1"

  "Added rear sensor value"

• Each controller shall use the 2-digit LED display to display meaningful info

  Maybe Geo Controller can display # of feet to destination

  Central controller can display number of CAN messages received per second.

• Each controller shall use the 4-LED lights for some indication

  LED0 should be lit if an error happens (common to everyone)

  Each LED should be labeled about what it means(maybe with a label machine?)

Robustness

Your project is one project as a whole. So if it doesn't work, do not blame it on "hey, their controller crashed". If a controller crashes it will restart, and you will have live with missing data messages. So your code should be robust, and self-recover from any crashed event or any brief power disruptions.

Likewise, if you send a message, and it fails (in case the other controller is down), your CAN bus may go to abnormal state and turn off. In this condition, all of your messages will fail, and you will have to handle this. I recommend the following:

• Attach a BUS off callback function that gives "can_bus_crashed" semaphore.
• If the semaphore is ever given, reset your CAN bus after a 3 second timeout.

Startup Tests

Since we rely on multiple controllers, it is critical to be able to test each controller quickly, reliably, and easily. So here is a startup test the Central Controller must process upon each boot:

• Central controller sends a message requesting boot information from each controller
• Central controller checks responses after about 100 ms:

  Each controller must have responded

  Each controller's boot code (normal, abnormal) should be validated.

Considerations

You should consider and design your software for all of these events:

• Where is the kill switch?
• Can you remotely shut down the car in 3 seconds?
• Where is the kill switch?
• If your controller goes down, will it fully recover to "last known configuration"?
• If critical sensor data stops coming, how will you stop the car?
• How can you quickly discover one or more controllers reaching an error state?
• Log the data on the SD card as much as possible.

  If something wrong happens, you need to know what happened.

  Each controller must log its "startup" time, to debug when a controller crashes and restarts

Grade

Your grade is relative. The best team earns the best grade. Remember than three out of three features working 100% is far better than nine out of ten features working. Focus on less features, with highest quality.

Sample Code

Part 1: Basic structure and CAN initialization

/************** can_msg_id.h *************/
#ifndef CAN_MSG_ID_H_
#define CAN_MSG_ID_H_


/**
 * Have an enumeration of controller IDs
 */
typedef enum :uint8_t {
    cid_geographical_controller = 1,
    cid_central_controller = 2,
    cid_broadcast = 0xff
} cid_t;

/// TODO Each controller shall set its own ID
#define OUR_CONTROLLER_ID       (cid_central_controller)

/**
 * Create a "union" whose struct overlaps with the uint32_t of CAN message id
 */
typedef union {
    /// This "raw" overlaps with <DST> <SRC> <ID>
    uint32_t raw;

    /// Struct members overlap with "raw"
    struct {
        uint32_t msg_num : 12; ///< Message number
        uint32_t src :  8;     ///< Source ID
        uint32_t dst :  8;     ///< Destination ID
    };
} __attribute__((packed)) controller_id_t;

/**
 * Creates a message ID based on the message ID protocol
 * @param [in] dst  The destination controller ID
 * @param [in] msg_num  The message number to send to the dst controller
 *
 * @returns  The 32-bit message ID created by the input parameters
 */
static inline uint32_t make_id(uint8_t dst, uint16_t msg_num)
{
    controller_id_t cid = { 0 };
    cid.msg_num  = msg_num;
    cid.src = OUR_CONTROLLER_ID;
    cid.dst = dst;
    return cid.raw;
}

#endif /* CAN_MSG_ID_H_ */

/************** main.cpp ************/
#include "can_msg_task_mgr.hpp"
#include "can.h"

int main(void)
{
    /* Initialize CAN Bus and set the acceptance filter(s) */
    CAN_init(can1, 100, 10, 10, NULL, NULL);
    /* TODO Initialize acceptance filters */
    CAN_reset_bus(can1);

    /* TODO: Enable periodic tasks */

    /* Start the scheduler to run all the tasks */
    scheduler_start(); 

    return 0;
}

Part 2: Periodic Parsing Task

Only one FreeRTOS periodic function should be responsible to receive CAN messages (while any task can send a CAN message). This receiving task should "route" the incoming messages to the appropriate "consumers" in your code.

void handle_msgs_function(void *p)
{
    can_msg_t msg;
    const controller_id_t *msgid = (controller_id_t *)(&(msg.msg_id));
    
    {
        while (CAN_rx(can1, &msg, portMAX_DELAY)) {
            /* TODO This is psuedocode, so add your real logic here */
            if (msgid->dst != cid_broadcast && msgid->dst != OUR_CONTROLLER_ID) {
                LOG_ERROR("CAN acceptance filter must be incorrect (0x%08X)!", msg.msg_id);
            }
            else if (common_command_message) {        /* 0x100 - 0x1FF */
                handle_common_cmd(msg);               /* 0x200 - 0x2FF */
            }
            else if (other_controller_response_msg) { /* 0x200 - 0x2FF */
                handle_cmd_rsp_msg(msg);
            }
            else if (our_command_message) {           /* 0x300 - 0x3FF */
                handle_our_cmd(msg);
            }
            else if (other_controller_data_message) { /* 0x500 - 0x5FF */
                handle_data_msg(msg);
            }
            else {
                LOG_ERROR("Unexpected Message ID: 0x%08X", msg.msg_id);
            }
        }
    }
}