#include "adcpp.hpp"
#include "blinker.hpp"
#include "timerpp.hpp"
#include "uartpp.hpp"
#include "shellpp.hpp"
#include "semaphorepp.hpp"
#include "motorpp.hpp"
#include "ir.hpp"
#include "drivepp.hpp"
#include "canpp.hpp"
#include "ctlsysctl.hpp"
#include "pingpp.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 sense-main.cpp:

Macros
#define	thread(x)

#define	can_data_length 5*2

#define	UART0_RX_BUFFER_SIZE 8

Functions
void	thread_blink_red ()

void	thread_blink_blue ()

void	thread_blink_green ()

void	thread_uart_update ()

void	__cxa_pure_virtual ()

void	Timer0A_Handler ()

void	Timer1A_Handler ()

void	GPIOPortD_Handler ()

void	UART0_Handler (void)

void	ADC0Seq0_Handler (void)

void	CAN0_Handler (void)

void	ping_handler ()

void	can_handler (void)

void	can_transmitter (void)

void	shell_handler ()

void	can_prepare_dummy_data (void)

int	main (void)

Variables
blinker	blink

timer	timer0a

uart	uart0

shell	shell0

adc	adc0

ir	ir0

ir	ir1

ir	ir2

ir	ir3

ping	ping0

semaphore *	ping0_sem

const uint32_t	can_msg_id = 1

const bool	can_sender = true

can	can0

uint8_t	can_data [5 *2]

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

Macro Definition Documentation

#define can_data_length 5*2

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

Referenced by can_prepare_dummy_data(), can_transmitter(), and main().

#define thread ( x )

Value:

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

Definition at line 34 of file sense-main.cpp.

Referenced by thread_blink_blue(), thread_blink_green(), thread_blink_red(), and thread_uart_update().

#define UART0_RX_BUFFER_SIZE 8

Definition at line 55 of file sense-main.cpp.

Function Documentation

void __cxa_pure_virtual ( )

Definition at line 95 of file sense-main.cpp.

95 { while (1) {} }

void ADC0Seq0_Handler ( void )

Definition at line 140 of file sense-main.cpp.

References adc::ack(), adc::sample(), and ir::sample().

                                        {
 
     adc0.ack();
     adc0.sample();
 
     ir0.sample();
     ir1.sample();
     ir2.sample();
     ir3.sample();
 }

Here is the call graph for this function:

void CAN0_Handler ( void )

Definition at line 151 of file sense-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 178 of file sense-main.cpp.

References can_data, can::get(), semaphore::guard(), uart::printf(), and can::recv_sem.

Referenced by main().

                        {
 
     while(1) {
         if(can0.recv_sem.guard()) {
 
             can0.get(can_data);
             uart0.printf("Received CAN data: %0X %0X %0X %0X %0X %0X %0X %0X ",
                          can_data[0], can_data[1], can_data[3], can_data[4],
                          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 can_prepare_dummy_data ( void )

Definition at line 284 of file sense-main.cpp.

References can_data, and can_data_length.

Referenced by main().

                                   {
 
     for(uint8_t i=0; i<can_data_length; ++i) {
         can_data[i] = i;
     }
 }

Here is the caller graph for this function:

void can_transmitter ( void )

Definition at line 192 of file sense-main.cpp.

References can_data, can_data_length, can_msg_id, ping::distance(), ir::distance(), PIN_BLUE, uart::printf(), sens_ir_left, sens_ir_left_front, sens_ir_right, sens_ir_right_front, sens_ping_front, blinker::toggle(), and can::transmit().

Referenced by main().

                            {
 
     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;
 
 
     /* 0 is left, left_front, right */
     /* 1 is right_front, front_ping */
     uint16_t can_msg_id = 0;
 
     uint8_t* ir_left_ptr;
     uint8_t* ir_left_front_ptr;
     uint8_t* ir_right_ptr;
     uint8_t* ir_right_front_ptr;
     uint8_t* ping_front_ptr;
     uint8_t* can_msg_id_ptr;
 
     ir_left_ptr = (uint8_t*)(&sens_ir_left);
     ir_left_front_ptr = (uint8_t*)(&sens_ir_left_front);
     ir_right_ptr = (uint8_t*)(&sens_ir_right);
     ir_right_front_ptr = (uint8_t*)(&sens_ir_right_front);
     ping_front_ptr = (uint8_t*)(&sens_ping_front);
     can_msg_id_ptr = (uint8_t*)(&can_msg_id);
 
     while(1) {
 
         if (can_msg_id == 0) {
             sens_ir_left = ir0.distance(); /* PE3 */
             sens_ir_left_front = ir1.distance(); /* PE2 */
             sens_ir_right = ir2.distance();      /* PE1 */
 
             can_data[0] = can_msg_id_ptr[0];
             can_data[1] = can_msg_id_ptr[1];
 
             can_data[2] = ir_left_ptr[0];
             can_data[3] = ir_left_ptr[1];
 
             can_data[4] = ir_left_front_ptr[0];
             can_data[5] = ir_left_front_ptr[1];
 
             can_data[6] = ir_right_ptr[0];
             can_data[7] = ir_right_ptr[1];
 
             can0.transmit(can_data, can_data_length);
             can_msg_id = 1;
         } else {
             sens_ping_front = ping0.distance();
             sens_ir_right_front = ir3.distance(); /* PE0 */
 
             can_data[0] = can_msg_id_ptr[0];
             can_data[1] = can_msg_id_ptr[1];
 
             can_data[2] = ir_right_front_ptr[0];
             can_data[3] = ir_right_front_ptr[1];
 
             can_data[4] = ping_front_ptr[0];
             can_data[5] = ping_front_ptr[1];
 
             can_data[6] = 0;
             can_data[7] = 0;
 
             can0.transmit(can_data, can_data_length);
             can_msg_id = 0;
         }
         uart0.printf("l: %u lf: %u r: %u rf: %u pf: %u\r\n",
                             sens_ir_left, sens_ir_left_front,
                             sens_ir_right, sens_ir_right_front,
                             sens_ping_front);
 
         blink.toggle(PIN_BLUE);
 
         os_surrender_context();
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void GPIOPortD_Handler ( )

Definition at line 105 of file sense-main.cpp.

References ping::handle_gpio().

                                     {
     ping0.handle_gpio();
 }

Here is the call graph for this function:

int main ( void )

Definition at line 291 of file sense-main.cpp.

References can_data_length, can_handler(), can_prepare_dummy_data(), can_sender, can_transmitter(), adc::configure_sequence(), adc::configure_timer_interrupt(), ping::get_sem(), ping_handler(), ctlsys::set_clock(), shell_handler(), adc::start(), and UART0_RX_SEM.

                {
 
     ctlsys::set_clock();
     IntMasterDisable();
 
     blink = blinker(GPIO_PORTF_BASE, GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3);
 
     timer0a = timer(0, TIMER_A, TIMER_CFG_PERIODIC, SysCtlClockGet() / 1000,
                     TIMER_TIMA_TIMEOUT, true);
 
     ping0 = ping(GPIO_PORTD_BASE, GPIO_PIN_3, 1, TIMER_A);
     ping0_sem = ping0.get_sem();
 
     adc0 = adc(ADC0_BASE, ADC_TRIGGER_TIMER, 0);
     adc0.configure_sequence(ADC_CTL_CH0); /* PE3 */
     adc0.configure_sequence(ADC_CTL_CH1); /* PE2 */
     adc0.configure_sequence(ADC_CTL_CH2); /* PE1 */
     adc0.configure_sequence(ADC_CTL_CH3 | ADC_CTL_IE | ADC_CTL_END); /* PE0 */
 
     adc0.configure_timer_interrupt(&timer0a);
     adc0.start();
 
     ir0 = ir(1, &adc0, 307042, -200, 14); /* PE3 */
     ir1 = ir(0, &adc0, 300147, -153, 11); /* PE2 */
     ir2 = ir(3, &adc0, 279094, -295, 8);  /* PE1 */
     ir3 = ir(2, &adc0, 302703, -198, 11); /* PE0 */
 
     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);
     if(can_sender) {
         can_prepare_dummy_data();
     }
 
     shell0 = shell(&uart0);
 
     os_threading_init();
     /* schedule(thread_blink_red, 200); */
     /* schedule(thread_blink_blue, 200); */
     /* schedule(thread_blink_green, 200); */
     schedule(ping_handler, 200);
     schedule(shell_handler, 200);
     if(can_sender) {
         schedule(can_transmitter, 200);
     } else {
         schedule(can_handler, 200);
     }
     os_launch();
 }

Here is the call graph for this function:

void ping_handler ( )

Definition at line 165 of file sense-main.cpp.

References semaphore::guard(), ping::sample(), and ping::start().

Referenced by main().

                     {
 
     ping0.start();
 
     while(1){
         if (ping0_sem->guard()) {
             ping0.sample();
             /* uart0.printf("ping: %u\n", ping0.average()); */
         }
         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 270 of file sense-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 thread_blink_blue ( )

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

References blink_count_blue, PIN_BLUE, thread, and blinker::toggle().

                          {
 
     thread (
             blink.toggle(PIN_BLUE);
             ++blink_count_blue;
         );
 }

Here is the call graph for this function:

void thread_blink_green ( )

Definition at line 79 of file sense-main.cpp.

References blink_count_green, PIN_GREEN, thread, and blinker::toggle().

                           {
 
     thread (
             blink.toggle(PIN_GREEN);
             ++blink_count_green;
         );
 }

Here is the call graph for this function:

void thread_blink_red ( )

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

References blink_count_red, PIN_RED, thread, and blinker::toggle().

                         {
 
     thread (
             blink.toggle(PIN_RED);
             ++blink_count_red;
         );
 }

Here is the call graph for this function:

void thread_uart_update ( )

Definition at line 87 of file sense-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 97 of file sense-main.cpp.

References timer::ack().

                                   {
     timer0a.ack();
 }

Here is the call graph for this function:

void Timer1A_Handler ( )

Definition at line 101 of file sense-main.cpp.

References ping::handle_timer().

                                   {
     ping0.handle_timer();
 }

Here is the call graph for this function:

void UART0_Handler ( void )

Definition at line 109 of file sense-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

adc adc0

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

blinker blink

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

uint32_t blink_count_blue = 0

Definition at line 61 of file sense-main.cpp.

Referenced by thread_blink_blue(), and thread_uart_update().

uint32_t blink_count_green = 0

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

Referenced by thread_blink_green(), and thread_uart_update().

uint32_t blink_count_red = 0

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

Referenced by thread_blink_red(), and thread_uart_update().

can can0

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

uint8_t can_data[5 *2]

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

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

const uint32_t can_msg_id = 1

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

Referenced by can_transmitter().

const bool can_sender = true

Definition at line 51 of file sense-main.cpp.

Referenced by main().

ir ir0

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

ir ir1

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

ir ir2

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

ir ir3

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

ping ping0

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

semaphore* ping0_sem

Definition at line 47 of file sense-main.cpp.

shell shell0

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

timer timer0a

Definition at line 41 of file sense-main.cpp.

uart uart0

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

buffer<char, 8 > UART0_RX_BUFFER

static

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

semaphore UART0_RX_SEM

static

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

Referenced by main().

Macros

Functions

Variables

Macro Definition Documentation

Function Documentation

Variable Documentation