#include "adcpp.hpp"
#include "blinker.hpp"
#include "uartpp.hpp"
#include "shellpp.hpp"
#include "semaphorepp.hpp"
#include "motorpp.hpp"
#include "drivepp.hpp"
#include "canpp.hpp"
#include "ctlsysctl.hpp"
#include "switchpp.hpp"
#include "libos/os.h"
#include "libschedule/schedule.h"
#include <stdint.h>
#include <stdlib.h>
#include <stdbool.h>
#include "inc/hw_memmap.h"
#include "driverlib/adc.h"
#include "driverlib/sysctl.h"
#include "driverlib/gpio.h"
#include "driverlib/interrupt.h"
#include "driverlib/uart.h"
#include "driverlib/pwm.h"

Include dependency graph for move-main.cpp:

Macros
#define	thread(x)

#define	can_data_length 10

#define	UART0_RX_BUFFER_SIZE 8

#define	BLINK_RED_WAIT_FOR_SEM 1

#define	BLINK_BLUE_WAIT_FOR_SEM 1

#define	BLINK_GREEN_WAIT_FOR_SEM 1

Functions
void	thread_blink_red ()

void	thread_blink_blue ()

void	thread_blink_green ()

void	thread_uart_update ()

void	__cxa_pure_virtual ()

void	UART0_Handler (void)

void	CAN0_Handler (void)

void	GPIOPortE_Handler ()

void	switch_responder ()

void	can_handler (void)

void	shell_handler ()

void	motor_control (void)

void	Timer1A_Handler ()

void	Timer0A_Handler ()

void	driver (void)

int	main (void)

Variables
blinker	blink

uart	uart0

shell	shell0

uint16_t	sens_ir_left

uint16_t	sens_ir_left_front

uint16_t	sens_ir_right

uint16_t	sens_ir_right_front

uint16_t	sens_ping_front

lswitch	switch0

semaphore	sem_switch

timer	countdown_timer

semaphore	motor_start

semaphore	motor_stop

motor	motor0

motor	motor1

drive	drive0

const uint32_t	can_msg_id = 1

const bool	can_sender = false

can	can0

uint8_t	can_data [10]

static semaphore	UART0_RX_SEM

static buffer< char, 8 >	UART0_RX_BUFFER

uint32_t	blink_count_red = 0

uint32_t	blink_count_green = 0

uint32_t	blink_count_blue = 0

semaphore	sem_blink_red

semaphore	sem_blink_blue

semaphore	sem_blink_green

Macro Definition Documentation

#define BLINK_BLUE_WAIT_FOR_SEM 1

Definition at line 75 of file move-main.cpp.

#define BLINK_GREEN_WAIT_FOR_SEM 1

Definition at line 76 of file move-main.cpp.

#define BLINK_RED_WAIT_FOR_SEM 1

Definition at line 74 of file move-main.cpp.

#define can_data_length 10

Definition at line 56 of file move-main.cpp.

Referenced by main().

#define thread ( x )

Value:

do {                            \
        x;                          \
        os_surrender_context();     \
    } while(true)

Definition at line 32 of file move-main.cpp.

Referenced by thread_uart_update().

#define UART0_RX_BUFFER_SIZE 8

Definition at line 62 of file move-main.cpp.

Function Documentation

void __cxa_pure_virtual ( )

Definition at line 131 of file move-main.cpp.

131 { while (1) {} }

void CAN0_Handler ( void )

Definition at line 164 of file move-main.cpp.

References can::ack(), can::error_tx(), semaphore::post(), and can::recv_sem.

                                    {
 
     uint32_t message_id = can0.ack();
 
     switch(message_id) {
     case 1:
         can0.recv_sem.post();
         break;
     default:
         can0.error_tx();
         break;
     }
 }

Here is the call graph for this function:

void can_handler ( void )

Definition at line 213 of file move-main.cpp.

References uart::atomic_printf(), can_data, can_msg_id, can::get(), semaphore::guard(), PIN_BLUE, can::recv_sem, sens_ir_left, sens_ir_left_front, sens_ir_right, sens_ir_right_front, sens_ping_front, and blinker::toggle().

Referenced by main().

                        {
 
     uint16_t can_msg_id;
 
     while(1) {
         if(can0.recv_sem.guard()) {
 
             can0.get(can_data);
             blink.toggle(PIN_BLUE);
 
             can_msg_id = (can_data[1] << 8) | (can_data[0]);
 
             if (can_msg_id == 0) {
                 sens_ir_left = (can_data[3] << 8) | (can_data[2]);
                 sens_ir_left_front = (can_data[5] << 8) | (can_data[4]);
                 sens_ir_right = (can_data[7] << 8) | (can_data[4]);
             } else {
                 sens_ir_right_front = (can_data[3] << 8) | (can_data[2]);
                 sens_ping_front = (can_data[5] << 8) | (can_data[4]);
             }
 
             uart0.atomic_printf("                                                \r");
             uart0.atomic_printf("l: %u lf: %u r: %u rf: %u pf: %u\r",
                                 sens_ir_left, sens_ir_left_front,
                                 sens_ir_right, sens_ir_right_front,
                                 sens_ping_front);
 
             /* uart0.atomic_printf("Received CAN data: %0X %0X %0X %0X %0X %0X %0X %0X \n", */
             /*                     can_data[0], can_data[1], can_data[2], can_data[3], */
             /*                     can_data[4], can_data[5], can_data[6], can_data[7]); */
         }
         os_surrender_context();
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void driver ( void )

Definition at line 287 of file move-main.cpp.

References sens_ir_left, sens_ir_left_front, sens_ir_right, sens_ir_right_front, sens_ping_front, and drive::steer().

Referenced by main().

                   {
 
     while(1) {
         drive0.steer(sens_ir_left, sens_ir_left_front,
                      sens_ir_right, sens_ir_right_front, sens_ping_front);
         os_surrender_context();
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void GPIOPortE_Handler ( )

Definition at line 178 of file move-main.cpp.

References lswitch::ack(), and lswitch::debounce().

                                     {
 
     switch0.ack();
     switch0.debounce();
 }

Here is the call graph for this function:

int main ( void )

Definition at line 296 of file move-main.cpp.

References can_data_length, can_handler(), can_sender, driver(), motor_control(), ctlsys::set_clock(), shell_handler(), switch_responder(), thread_blink_blue(), thread_blink_green(), thread_blink_red(), and UART0_RX_SEM.

                {
 
     ctlsys::set_clock();
     IntMasterDisable();
 
     blink = blinker(GPIO_PORTF_BASE, GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3);
 
     sem_blink_red = semaphore();
     sem_blink_green = semaphore();
     sem_blink_blue = semaphore();
 
     UART0_RX_BUFFER = buffer<char, UART0_RX_BUFFER_SIZE>(&UART0_RX_SEM);
     uart0 = uart(UART0_BASE, INT_UART0);
 
     can0 = can(CAN0_BASE, INT_CAN0, can_sender, can_data_length);
 
     motor_start = semaphore();
     motor_stop = semaphore();
     shell0 = shell(&uart0, &motor_start, &motor_stop);
     motor0 = motor(GPIO_PORTA_BASE, GPIO_PIN_6, PWM0_BASE, PWM_GEN_0, PWM_OUT_0);
     motor1 = motor(GPIO_PORTA_BASE, GPIO_PIN_7, PWM0_BASE, PWM_GEN_0, PWM_OUT_1);
     drive0 = drive(&motor0, &motor1, 50);
     countdown_timer = timer(0, TIMER_BOTH, TIMER_CFG_ONE_SHOT, SysCtlClockGet()*180,
                             TIMER_TIMA_TIMEOUT, true);
     switch0 = lswitch(GPIO_PORTE_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3,
                       &sem_switch, 1, TIMER_A, GPIO_BOTH_EDGES,
                       INT_GPIOE_TM4C123, true);
 
     os_threading_init();
     schedule(motor_control, 200);
     schedule(thread_blink_red, 200);
     schedule(thread_blink_blue, 200);
     schedule(thread_blink_green, 200);
     schedule(shell_handler, 200);
     /* schedule(thread_uart_update, 200); */
     schedule(switch_responder, 200);
     schedule(driver, 200);
     schedule(can_handler, 200);
     os_launch();
 }

Here is the call graph for this function:

void motor_control ( void )

Allows motor control from shell

Definition at line 263 of file move-main.cpp.

References semaphore::guard(), drive::start(), and drive::stop().

Referenced by main().

                          {
 
     while(1) {
         if(motor_start.guard()) {
             drive0.start();
         }
         if(motor_stop.guard()) {
             drive0.stop();
         }
         os_surrender_context();
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void shell_handler ( )

Definition at line 248 of file move-main.cpp.

References shell::accept(), buffer< T, N >::get(), and semaphore::guard().

Referenced by main().

                      {
 
     while(1) {
         if(UART0_RX_SEM.guard()) {
 
             bool ok;
             char recv = UART0_RX_BUFFER.get(ok);
 
             if(ok) { shell0.accept(recv); }
         }
         os_surrender_context();
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void switch_responder ( )

Definition at line 184 of file move-main.cpp.

References lswitch::debounced_data, semaphore::guard(), drive::reset_history(), and motor::reverse().

Referenced by main().

                         {
 
     const uint32_t counter_max = SysCtlClockGet()/25;
     uint32_t pins, counter;
     percent_t left_speed, right_speed;
 
     while(1) {
         if(sem_switch.guard() && switch0.debounced_data) {
             counter = 0;
 
             if(switch0.debounced_data & GPIO_PIN_1) {
                 left_speed = 100;
                 right_speed = 0;
             } else if(switch0.debounced_data & GPIO_PIN_2) {
                 left_speed = 0;
                 right_speed = 100;
             }
 
             motor0.reverse();
             motor1.reverse();
             while (++counter < counter_max) { }
             motor0.reverse();
             motor1.reverse();
             drive0.reset_history();
         }
         os_surrender_context();
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void thread_blink_blue ( )

Definition at line 93 of file move-main.cpp.

References blink_count_blue, semaphore::guard(), PIN_BLUE, and blinker::toggle().

Referenced by main().

                          {
 
     while(1) {
 #if BLINK_BLUE_WAIT_FOR_SEM == 1
         if (sem_blink_blue.guard()) {
 #endif
             blink.toggle(PIN_BLUE);
             ++blink_count_blue;
 #if BLINK_BLUE_WAIT_FOR_SEM == 1
         }
 #endif
         os_surrender_context();
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void thread_blink_green ( )

Definition at line 108 of file move-main.cpp.

References blink_count_green, semaphore::guard(), PIN_GREEN, and blinker::toggle().

Referenced by main().

                           {
 
     while(1) {
 #if BLINK_GREEN_WAIT_FOR_SEM == 1
         if (sem_blink_green.guard()) {
 #endif
             blink.toggle(PIN_GREEN);
             ++blink_count_green;
 #if BLINK_GREEN_WAIT_FOR_SEM == 1
         }
 #endif
         os_surrender_context();
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void thread_blink_red ( )

Definition at line 78 of file move-main.cpp.

References blink_count_red, semaphore::guard(), PIN_RED, and blinker::toggle().

Referenced by main().

                         {
 
     while(1) {
 #if BLINK_RED_WAIT_FOR_SEM == 1
         if (sem_blink_red.guard()) {
 #endif
             blink.toggle(PIN_RED);
             ++blink_count_red;
 #if BLINK_RED_WAIT_FOR_SEM == 1
         }
 #endif
         os_surrender_context();
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void thread_uart_update ( )

Definition at line 123 of file move-main.cpp.

References uart::atomic_printf(), blink_count_blue, blink_count_green, blink_count_red, and thread.

                           {
 
     thread (
             uart0.atomic_printf("%x %x %x\n\r", blink_count_red,
                                 blink_count_blue, blink_count_green);
         );
 }

Here is the call graph for this function:

void Timer0A_Handler ( )

Definition at line 281 of file move-main.cpp.

References timer::ack(), and drive::stop().

                                   {
 
     countdown_timer.ack();
     drive0.stop();
 }

Here is the call graph for this function:

void Timer1A_Handler ( )

Definition at line 276 of file move-main.cpp.

References lswitch::end_debounce().

                                   {
 
     switch0.end_debounce();
 }

Here is the call graph for this function:

void UART0_Handler ( void )

Definition at line 133 of file move-main.cpp.

References uart::ack(), blinker::blink(), uart::get_char(), uart::LAST_WAS_CR, buffer< T, N >::notify(), and PIN_RED.

                                     {
 
     if(!(uart0.ack() & (UART_INT_RX | UART_INT_RT))) {
         return;
     }
 
     while(UARTCharsAvail(UART0_BASE)) {
         char recv = uart0.get_char();
 
         /* Regardless of newline received, our convention is to
          * mark end-of-lines in a buffer with the CR character. */
         switch(recv) {
         case '\n':
             if (uart::LAST_WAS_CR) {
                 uart::LAST_WAS_CR = false;
                 continue;
             }
             break;
         case '\r':
             uart::LAST_WAS_CR = true;
             break;
         case 0x1b:
             recv = '\r';
             break;
         default: break;
         }
         UART0_RX_BUFFER.notify((const int8_t) recv);
         blink.blink(PIN_RED);
     }
 }

Here is the call graph for this function:

Variable Documentation

blinker blink

Definition at line 38 of file move-main.cpp.

Referenced by shell::doctor(), shell::jester(), and shell::witch().

uint32_t blink_count_blue = 0

Definition at line 68 of file move-main.cpp.

Referenced by thread_blink_blue(), and thread_uart_update().

uint32_t blink_count_green = 0

Definition at line 67 of file move-main.cpp.

Referenced by thread_blink_green(), and thread_uart_update().

uint32_t blink_count_red = 0

Definition at line 66 of file move-main.cpp.

Referenced by thread_blink_red(), and thread_uart_update().

can can0

Definition at line 59 of file move-main.cpp.

uint8_t can_data[10]

Definition at line 60 of file move-main.cpp.

Referenced by can_handler().

const uint32_t can_msg_id = 1

Definition at line 57 of file move-main.cpp.

Referenced by can_handler().

const bool can_sender = false

Definition at line 58 of file move-main.cpp.

Referenced by can::can(), and main().

timer countdown_timer

Definition at line 50 of file move-main.cpp.

drive drive0

Definition at line 54 of file move-main.cpp.

motor motor0

Definition at line 53 of file move-main.cpp.

motor motor1

Definition at line 53 of file move-main.cpp.

semaphore motor_start

Definition at line 52 of file move-main.cpp.

semaphore motor_stop

Definition at line 52 of file move-main.cpp.

semaphore sem_blink_blue

Definition at line 71 of file move-main.cpp.

semaphore sem_blink_green

Definition at line 72 of file move-main.cpp.

semaphore sem_blink_red

Definition at line 70 of file move-main.cpp.

semaphore sem_switch

Definition at line 49 of file move-main.cpp.

uint16_t sens_ir_left

Definition at line 42 of file move-main.cpp.

Referenced by can_handler(), can_transmitter(), and driver().

uint16_t sens_ir_left_front

Definition at line 43 of file move-main.cpp.

Referenced by can_handler(), can_transmitter(), and driver().

uint16_t sens_ir_right

Definition at line 44 of file move-main.cpp.

Referenced by can_handler(), can_transmitter(), and driver().

uint16_t sens_ir_right_front

Definition at line 45 of file move-main.cpp.

Referenced by can_handler(), can_transmitter(), and driver().

uint16_t sens_ping_front

Definition at line 46 of file move-main.cpp.

Referenced by can_handler(), can_transmitter(), and driver().

shell shell0

Definition at line 40 of file move-main.cpp.

lswitch switch0

Definition at line 48 of file move-main.cpp.

uart uart0

Definition at line 39 of file move-main.cpp.

buffer<char, 8 > UART0_RX_BUFFER

static

Definition at line 64 of file move-main.cpp.

semaphore UART0_RX_SEM

static

Definition at line 63 of file move-main.cpp.

Referenced by main().

Macros

Functions

Variables

Macro Definition Documentation

Function Documentation

Variable Documentation