devoalda
/
INF2004_Project
mirror of https://github.com/L4ncelot-R/freeRTOS-car.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'obstacle-branch' of https://github.com/L4ncelot-R/freeRTOS-car into obstacle-branch

This commit is contained in:
xypoon 2023-11-09 12:29:09 +08:00
parent 69e0e222dc b36e4c93a3
commit 5dabf0edc8
4 changed files with 89 additions and 341 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
frtos/config/line_sensor_config.h
View File

@ -7,11 +7,17 @@
#define LEFT_SENSOR_PIN ( 26 ) #define LEFT_SENSOR_PIN ( 26 )
#define RIGHT_SENSOR_PIN ( 27 ) #define RIGHT_SENSOR_PIN ( 27 )
#define BARCODE_SENSOR_PIN ( 22 )
typedef struct s_obs_struct {
uint8_t line_detected;
bool ultrasonic_detected;
} obs_t;
/* Map */ typedef struct
#define MAP_START_SYMBOL ( 5 ) {
#define MAP_SIZE 20 obs_t *obs;
} line_car_struct_t;
#endif //CONFIG_H #endif //CONFIG_H

175
frtos/line_sensor/line_sensor.h
View File

@ -4,58 +4,11 @@
* @author Woon Jun Wei * @author Woon Jun Wei
*/ */
#ifndef LINE_SENSOR_H
#define LINE_SENSOR_H
#include "line_sensor_init.h" #include "line_sensor_init.h"
/**
* @brief Monitor the left sensor
*
* This function will monitor the left sensor and send the state to the
* left sensor message buffer, used to calculate the direction of the car
*
* @param params
*/
//void
//monitor_left_sensor_task(__unused void *params) {
// for (;;)
// {
// if (xSemaphoreTake(g_left_sensor_sem, portMAX_DELAY) == pdTRUE)
// {
// if (left_sensor_triggered == pdTRUE)
// {
// printf("left sensor triggered\n");
// // Get Current State
// state_t state = gpio_get(LEFT_SENSOR_PIN);
//
// xMessageBufferSend(left_sensor_msg_buffer,
// &state,
// sizeof(state_t),
// 0);
// // Reset the flag
// left_sensor_triggered = pdFALSE;
// }
// }
// }
//}
void
monitor_left_sensor_task(__unused void *params) {
for (;;)
{
if (xSemaphoreTake(g_left_sensor_sem, portMAX_DELAY) == pdTRUE)
{
printf("left sensor triggered\n");
// Get Current State
state_t state = gpio_get(LEFT_SENSOR_PIN);
xMessageBufferSend(left_sensor_msg_buffer,
&state,
sizeof(state_t),
0);
}
}
}
/** /**
* @brief Monitor the right sensor * @brief Monitor the right sensor
* *
@ -85,59 +38,25 @@ monitor_left_sensor_task(__unused void *params) {
// } // }
//} //}
void //void
monitor_right_sensor_task(void *params) { //monitor_right_sensor_task(void *pvParameters) {
for (;;) { //
if (xSemaphoreTake(g_right_sensor_sem, portMAX_DELAY) == pdTRUE) { // volatile
// Check the flag or receive the message // for (;;) {
printf("right sensor triggered\n"); // if (xSemaphoreTake(g_right_sensor_sem, portMAX_DELAY) == pdTRUE) {
// Get Current State // // Check the flag or receive the message
state_t state = gpio_get(RIGHT_SENSOR_PIN); // printf("right sensor triggered\n");
// // Get Current State
// state_t state = gpio_get(RIGHT_SENSOR_PIN);
//
//// xMessageBufferSend(right_sensor_msg_buffer,
//// &state,
//// sizeof(state_t),
//// 0);
// }
// }
//}
xMessageBufferSend(right_sensor_msg_buffer,
&state,
sizeof(state_t),
0);
}
}
}
/**
* @brief Monitor the barcode sensor
*
* This function will monitor the barcode sensor and send the state to the
* barcode sensor message buffer, used to scan the barcode below the car
*
* @param params
*/
void monitor_barcode_sensor_task(void *params) {
for (;;) {
if (xSemaphoreTake(g_barcode_sensor_sem, portMAX_DELAY) == pdTRUE) {
// Check the flag or receive the message
if (barcode_sensor_triggered == pdTRUE) {
uint32_t barcode_data = 0;
for (int i = 0; i < 9; i++) {
sleep_ms(100); // Wait for a segment of the barcode
if (gpio_get(BARCODE_SENSOR_PIN)) {
barcode_data |= (1u << i);
} else {
barcode_data &= ~(1u << i);
}
}
printf("Barcode Data (binary): %09b\n", barcode_data);
// Send or process the barcode data
xMessageBufferSend(barcode_sensor_msg_buffer, &barcode_data, sizeof(uint32_t), 0);
// Reset the flag
barcode_sensor_triggered = pdFALSE;
}
}
}
}
/** /**
* @brief Monitor the direction and Oritentation of the car * @brief Monitor the direction and Oritentation of the car
* *
@ -146,29 +65,29 @@ void monitor_barcode_sensor_task(void *params) {
* *
* @param params * @param params
*/ */
void //void
monitor_direction_task(__unused void *params) { //monitor_direction_task(__unused void *params) {
state_t left_state; // state_t left_state;
state_t right_state; // state_t right_state;
state_t barcode_state; // state_t barcode_state;
//
for (;;) // for (;;)
{ // {
// Receive from Buffer // // Receive from Buffer
xMessageBufferReceive(left_sensor_msg_buffer, // xMessageBufferReceive(left_sensor_msg_buffer,
&left_state, // &left_state,
sizeof(state_t), // sizeof(state_t),
portMAX_DELAY); // portMAX_DELAY);
//
xMessageBufferReceive(right_sensor_msg_buffer, // xMessageBufferReceive(right_sensor_msg_buffer,
&right_state, // &right_state,
sizeof(state_t), // sizeof(state_t),
portMAX_DELAY); // portMAX_DELAY);
//
xMessageBufferReceive(barcode_sensor_msg_buffer, // xMessageBufferReceive(barcode_sensor_msg_buffer,
&barcode_state, // &barcode_state,
sizeof(state_t), // sizeof(state_t),
portMAX_DELAY); // portMAX_DELAY);
// g_car_state.current_direction = (left_state << 1) | right_state; // g_car_state.current_direction = (left_state << 1) | right_state;
@ -220,5 +139,7 @@ monitor_direction_task(__unused void *params) {
// printf("Orientation: Error\n"); // printf("Orientation: Error\n");
// break; // break;
// } // }
} // }
} //}
#endif /* LINE_SENSOR_H */

167
frtos/line_sensor/line_sensor_init.h
View File

@ -19,63 +19,8 @@
#include "line_sensor_config.h" #include "line_sensor_config.h"
#define DEBOUNCE_DELAY_MS 100
static TickType_t lastEdgeTimeLeft = 0;
static TickType_t lastEdgeTimeRight = 0;
static TickType_t lastBarcodeTime = 0;
typedef enum { // Unused, useful for readability
LINE_DETECTED = 0,
LINE_NOT_DETECTED = 1,
} state_t;
//typedef enum {
// ERROR = 0,
// RIGHT = 1,
// LEFT = 2,
// FORWARD = 3
//} direction_t;
//typedef enum {
// NORTH = 0,
// EAST = 1,
// SOUTH = 2,
// WEST = 3,
//} orientation_t;
//typedef struct {
// uint8_t x; // Current x coordinate
// uint8_t y; // Current y coordinate
// direction_t current_direction; // Current direction (forward, left, right)
// orientation_t orientation; // Current orientation (N, E, S, W)
//} car_state_t;
// Semaphore // Semaphore
SemaphoreHandle_t g_left_sensor_sem = NULL; SemaphoreHandle_t g_left_sensor_sem = NULL;
SemaphoreHandle_t g_right_sensor_sem = NULL;
SemaphoreHandle_t g_barcode_sensor_sem = NULL;
// Queue
static MessageBufferHandle_t left_sensor_msg_buffer; // Left Sensor Buffer
static MessageBufferHandle_t right_sensor_msg_buffer; // Right Sensor Buffer
static MessageBufferHandle_t barcode_sensor_msg_buffer; // Barcode Sensor Buffer
static volatile BaseType_t right_sensor_triggered = pdFALSE;
static volatile BaseType_t left_sensor_triggered = pdFALSE;
static volatile BaseType_t barcode_sensor_triggered = pdFALSE;
//// Car State Struct
//static car_state_t g_car_state;
//
//static car_state_t initialize_car_state() {
// g_car_state.x = MAP_SIZE >> 1;
// g_car_state.y = MAP_SIZE >> 1;
// g_car_state.current_direction = FORWARD;
// g_car_state.orientation = NORTH;
//
// return g_car_state;
//}
/** /**
* @brief Setup the Line Sensor * @brief Setup the Line Sensor
@ -83,21 +28,19 @@ static volatile BaseType_t barcode_sensor_triggered = pdFALSE;
* This function will setup the Line Sensor by initializing it as an input * This function will setup the Line Sensor by initializing it as an input
*/ */
static inline void static inline void
line_sensor_setup() { line_sensor_init(line_car_struct_t *p_car) {
g_left_sensor_sem = xSemaphoreCreateBinary(); obs_t obs = {1, 0};
g_right_sensor_sem = xSemaphoreCreateBinary();
g_barcode_sensor_sem = xSemaphoreCreateBinary();
uint mask = (1 << LEFT_SENSOR_PIN) | (1 << RIGHT_SENSOR_PIN) | (1 << BARCODE_SENSOR_PIN); p_car->obs = &obs;
g_left_sensor_sem = xSemaphoreCreateBinary();
uint mask = (1 << LEFT_SENSOR_PIN) | (1 << RIGHT_SENSOR_PIN);
// Initialise 3 GPIO pins and set them to input // Initialise 3 GPIO pins and set them to input
gpio_init_mask(mask); gpio_init_mask(mask);
gpio_set_dir_in_masked(mask); gpio_set_dir_in_masked(mask);
left_sensor_msg_buffer = xMessageBufferCreate(30);
right_sensor_msg_buffer = xMessageBufferCreate(30);
barcode_sensor_msg_buffer = xMessageBufferCreate(30);
} }
/** /**
@ -114,100 +57,22 @@ bool h_left_sensor_timer_handler(repeating_timer_t *repeatingTimer) {
return true; return true;
} }
/**
* @brief Timer Interrupt Handler for the right sensor
*
* @param repeatingTimer
* @return True (To keep the timer running)
*/
bool h_right_sensor_timer_handler(repeating_timer_t *repeatingTimer) {
BaseType_t xHigherPriorityTaskWoken = pdFALSE; void
xSemaphoreGiveFromISR(g_right_sensor_sem, monitor_left_sensor_task(void *pvParameters) {
&xHigherPriorityTaskWoken); volatile obs_t *p_obs = NULL;
portYIELD_FROM_ISR(xHigherPriorityTaskWoken); p_obs = (obs_t *) pvParameters;
return true; for (;;)
}
/**
* @brief Timer Interrupt Handler for the barcode sensor
*
* @param repeatingTimer
* @return True (To keep the timer running)
*/
bool h_barcode_sensor_timer_handler(repeating_timer_t *repeatingTimer) {
BaseType_t xHigherPriorityTaskWoken = pdFALSE;
xSemaphoreGiveFromISR(g_barcode_sensor_sem,
&xHigherPriorityTaskWoken);
portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
return true;
}
void h_line_sensor_handler(void) {
BaseType_t xHigherPriorityTaskWoken = pdFALSE;
TickType_t currentTicks = xTaskGetTickCount();
printf("Interrupt triggered\n");
if (gpio_get_irq_event_mask(LEFT_SENSOR_PIN) & GPIO_IRQ_EDGE_FALL)
{ {
if ((currentTicks - lastEdgeTimeLeft) >= if (xSemaphoreTake(g_left_sensor_sem, portMAX_DELAY) == pdTRUE)
pdMS_TO_TICKS(DEBOUNCE_DELAY_MS))
{ {
lastEdgeTimeLeft = currentTicks;
gpio_acknowledge_irq(LEFT_SENSOR_PIN, GPIO_IRQ_EDGE_FALL);
left_sensor_triggered = pdTRUE;
xSemaphoreGiveFromISR(g_left_sensor_sem, &xHigherPriorityTaskWoken);
}
else
{
// Reset the timer to the currentTicks if the edge is ignored
lastEdgeTimeLeft = currentTicks;
}
}
if (gpio_get_irq_event_mask(RIGHT_SENSOR_PIN) & GPIO_IRQ_EDGE_FALL)
{
if ((currentTicks - lastEdgeTimeRight) >=
pdMS_TO_TICKS(DEBOUNCE_DELAY_MS))
{
lastEdgeTimeRight = currentTicks;
gpio_acknowledge_irq(RIGHT_SENSOR_PIN, GPIO_IRQ_EDGE_FALL);
// Set the flag to notify the task // Set the flag to notify the task
right_sensor_triggered = pdTRUE; p_obs->line_detected = gpio_get(LEFT_SENSOR_PIN);
xSemaphoreGiveFromISR(g_right_sensor_sem, printf("Left Sensor: %d\n", p_obs->line_detected);
&xHigherPriorityTaskWoken);
}
else
{
// Reset the timer to the currentTicks if the edge is ignored
lastEdgeTimeRight = currentTicks;
} }
} }
if (gpio_get_irq_event_mask(BARCODE_SENSOR_PIN) & GPIO_IRQ_EDGE_FALL)
{
if ((currentTicks - lastBarcodeTime) >=
pdMS_TO_TICKS(DEBOUNCE_DELAY_MS))
{
lastBarcodeTime = currentTicks;
gpio_acknowledge_irq(BARCODE_SENSOR_PIN, GPIO_IRQ_EDGE_FALL);
// Set the flag to notify the task
barcode_sensor_triggered = pdTRUE;
xSemaphoreGiveFromISR(g_barcode_sensor_sem,
&xHigherPriorityTaskWoken);
}
else
{
// Reset the timer to the currentTicks if the edge is ignored
lastBarcodeTime = currentTicks;
}
}
portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
} }
#endif /* LINE_SENSOR_INIT_H */ #endif /* LINE_SENSOR_INIT_H */

72
frtos/line_sensor/line_sensor_test.c
View File

@ -1,88 +1,44 @@
#include "line_sensor.h" #include "line_sensor_init.h"
#define READ_LEFT_SENSOR_PRIO (tskIDLE_PRIORITY + 2UL) #define READ_LEFT_SENSOR_PRIO (tskIDLE_PRIORITY + 2UL)
#define READ_RIGHT_SENSOR_PRIO (tskIDLE_PRIORITY + 2UL)
#define READ_RIGHT_SENSOR_PRIO (tskIDLE_PRIORITY + 2UL)
#define DIRECTION_TASK_PRIORITY (tskIDLE_PRIORITY + 3UL)
void void
launch() launch(line_car_struct_t *car_struct)
{ {
// isr to detect left line sensor
gpio_set_irq_enabled(LEFT_SENSOR_PIN, GPIO_IRQ_EDGE_FALL, true);
gpio_add_raw_irq_handler(LEFT_SENSOR_PIN, h_line_sensor_handler);
// isr to detect right line sensor
gpio_set_irq_enabled(RIGHT_SENSOR_PIN, GPIO_IRQ_EDGE_FALL, true);
gpio_add_raw_irq_handler(RIGHT_SENSOR_PIN, h_line_sensor_handler);
// isr to detect barcode line sensor
gpio_set_irq_enabled(BARCODE_SENSOR_PIN, GPIO_IRQ_EDGE_FALL, true);
gpio_add_raw_irq_handler(BARCODE_SENSOR_PIN, h_line_sensor_handler);
irq_set_enabled(IO_IRQ_BANK0, true);
struct repeating_timer g_left_sensor_timer; struct repeating_timer g_left_sensor_timer;
add_repeating_timer_ms(LINE_SENSOR_READ_DELAY, add_repeating_timer_ms(LINE_SENSOR_READ_DELAY,
h_left_sensor_timer_handler, h_left_sensor_timer_handler,
NULL, NULL,
&g_left_sensor_timer); &g_left_sensor_timer);
struct repeating_timer g_right_sensor_timer; TaskHandle_t h_monitor_left_sensor_task = NULL;
add_repeating_timer_ms(LINE_SENSOR_READ_DELAY,
h_right_sensor_timer_handler,
NULL,
&g_right_sensor_timer);
TaskHandle_t h_monitor_left_sensor_task;
xTaskCreate(monitor_left_sensor_task, xTaskCreate(monitor_left_sensor_task,
"Monitor Left Sensor Task", "read_left_sensor_task",
configMINIMAL_STACK_SIZE, configMINIMAL_STACK_SIZE,
NULL, (void *)car_struct->obs,
READ_LEFT_SENSOR_PRIO, READ_LEFT_SENSOR_PRIO,
&h_monitor_left_sensor_task); &h_monitor_left_sensor_task);
TaskHandle_t h_monitor_right_sensor_task;
xTaskCreate(monitor_right_sensor_task,
"Monitor Right Sensor Task",
configMINIMAL_STACK_SIZE,
NULL,
READ_RIGHT_SENSOR_PRIO,
&h_monitor_right_sensor_task);
TaskHandle_t h_monitor_barcode_sensor_task;
xTaskCreate(monitor_barcode_sensor_task,
"Monitor Barcode Sensor Task",
configMINIMAL_STACK_SIZE,
NULL,
READ_RIGHT_SENSOR_PRIO,
&h_monitor_right_sensor_task);
// TaskHandle_t h_monitor_direction_task;
// xTaskCreate(monitor_direction_task,
// "Monitor Direction Task",
// configMINIMAL_STACK_SIZE,
// NULL,
// DIRECTION_TASK_PRIORITY,
// &h_monitor_direction_task);
vTaskStartScheduler(); vTaskStartScheduler();
} }
int int
main (void) main(void)
{ {
stdio_usb_init(); stdio_usb_init();
// sleep_ms(2000); obs_t obs = { 0, 0 };
line_car_struct_t car_struct = { .obs = &obs };
sleep_ms(2000);
printf("Test started!\n"); printf("Test started!\n");
line_sensor_setup(); line_sensor_init(&car_struct);
initialize_car_state();
launch(); launch(&car_struct);
return (0); return (0);
} }