test-os.c File Reference

#include <stdint.h>
#include <stdbool.h>
#include "inc/hw_ints.h"
#include "inc/hw_memmap.h"
#include "driverlib/debug.h"
#include "driverlib/gpio.h"
#include "driverlib/interrupt.h"
#include "driverlib/pin_map.h"
#include "driverlib/sysctl.h"
#include "driverlib/systick.h"
#include "driverlib/uart.h"
#include "libos/os.h"
#include "libheart/heartbeat.h"
#include "libhw/hardware.h"
#include "libstd/nexus.h"
#include <sys/stat.h>

Include dependency graph for test-os.c:

Go to the source code of this file.

Macros
#define	HEARTBEAT_MODAL
#define	UART_FIFO_SIZE   0x7f
#define	PIDWORK_BUFFER_SIZE   0x7f

Functions
void	Thread1 (void)
void	Thread2 (void)
void	uart_consumer (void)
int	main ()

Variables
volatile uint32_t	pidwork
volatile uint32_t	highest_pidwork
volatile uint32_t	lowest_pidwork
volatile uint32_t	pidwork_idx
volatile uint32_t *	pidwork_buffer
volatile uint32_t	uart_producer_idx
volatile uint32_t	uart_consumer_idx
volatile char *	uart_fifo
volatile uint32_t	uart_dropped_chars

Macro Definition Documentation

#define HEARTBEAT_MODAL

Definition at line 22 of file test-os.c.

#define PIDWORK_BUFFER_SIZE   0x7f

Definition at line 32 of file test-os.c.

Referenced by main(), pidwork_record(), and Thread2().

#define UART_FIFO_SIZE   0x7f

Definition at line 31 of file test-os.c.

Referenced by main(), and uart_consumer().

Function Documentation

int main

(

void

)

A thread that continuously toggles GPIO pin 3 on GPIO_PORT_F.

Definition at line 93 of file test-os.c.

References GPIO_PIN_0, GPIO_PIN_1, GPIO_PIN_2, GPIO_PIN_3, GPIO_PORTA_BASE, GPIO_PORTF_BASE, GPIOPinConfigure(), GPIOPinTypeUART(), heart_init(), highest_pidwork, Hz, IntMasterDisable(), IntMasterEnable(), lowest_pidwork, os_add_thread(), OS_INTERACTIVE_POOL, os_launch(), os_threading_init(), pidwork, pidwork_buffer, PIDWORK_BUFFER_SIZE, pidwork_idx, postpone_death, SYSCTL_OSC_MAIN, SYSCTL_PERIPH_GPIOA, SYSCTL_PERIPH_UART0, SYSCTL_SYSDIV_1, SYSCTL_USE_OSC, SYSCTL_XTAL_16MHZ, SysCtlClockGet(), SysCtlClockSet(), SysCtlPeripheralEnable(), Thread1(), Thread2(), UART0_BASE, UART_CONFIG_PAR_NONE, UART_CONFIG_STOP_ONE, UART_CONFIG_WLEN_8, UART_FIFO_SIZE, and UARTConfigSetExpClk().

           {

    char uart_fifo_raw[UART_FIFO_SIZE];
    uint32_t pidwork_buffer_raw[PIDWORK_BUFFER_SIZE];

    SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |
                   SYSCTL_XTAL_16MHZ);

    IntMasterDisable();

    /* Initialize global variables */
    pidwork = 0;
    highest_pidwork = 0;
    lowest_pidwork = (uint32_t)(-1);
    pidwork_buffer = pidwork_buffer_raw;
    pidwork_idx = 0;

    /* Enable the UART */
    SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
    GPIOPinConfigure(GPIO_PA0_U0RX);
    GPIOPinConfigure(GPIO_PA1_U0TX);
    GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
    UARTConfigSetExpClk(UART0_BASE, SysCtlClockGet(),
                        115200, (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE |
                                 UART_CONFIG_PAR_NONE));

    /* Enable the UART interrupt. */

    /* IntEnable(INT_UART0); */
    /* UARTIntEnable(UART0_BASE, UART_INT_RX | UART_INT_RT); */
    /* uart_fifo = uart_fifo_raw; */
    /* uart_producer_idx = 0; */
    /* uart_consumer_idx = UART_FIFO_SIZE - 1; */

    os_threading_init(100 Hz);
    os_add_thread(Thread1, OS_INTERACTIVE_POOL);
    os_add_thread(Thread2, OS_INTERACTIVE_POOL);
    /* os_add_thread(hw_daemon, OS_SYSTEM_POOL); */

    heart_init();
    heart_init_(GPIO_PORTF_BASE, GPIO_PIN_1);
    heart_init_(GPIO_PORTF_BASE, GPIO_PIN_2);
    heart_init_(GPIO_PORTF_BASE, GPIO_PIN_3);

    /* os_trap_ */
    os_launch();

    /* PONDER: why do interrupts fire without this? */
    IntMasterEnable();
    postpone_death();
}

Here is the call graph for this function:

void Thread1

(

void

)

A thread that continuously toggles GPIO pin 1 on GPIO_PORT_F.

Definition at line 46 of file test-os.c.

References atomic, GPIO_PIN_1, GPIO_PIN_2, GPIO_PORTF_BASE, GPIOPinRead(), GPIOPinWrite(), and pidwork.

Referenced by main().

                  {
    while(1) {
        /* BEGIN CRITICAL SECTION */
    atomic (
        ++pidwork;
        );
        /* END CRITICAL SECTION */
        GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1 | GPIO_PIN_2,
                     GPIO_PIN_1 ^ GPIOPinRead(GPIO_PORTF_BASE, GPIO_PIN_1));
    /* os_surrender_context(); */
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Thread2

(

void

)

A thread that continuously toggles GPIO pin 2 on GPIO_PORT_F.

Definition at line 60 of file test-os.c.

References GPIO_PIN_1, GPIO_PIN_2, GPIO_PORTF_BASE, GPIOPinRead(), GPIOPinWrite(), highest_pidwork, lowest_pidwork, pidwork, pidwork_buffer, PIDWORK_BUFFER_SIZE, and pidwork_idx.

Referenced by main().

                  {
    while(1) {
        GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1 | GPIO_PIN_2,
                     GPIO_PIN_2 ^ GPIOPinRead(GPIO_PORTF_BASE, GPIO_PIN_2));
        if (pidwork != 0) {
            if (highest_pidwork < pidwork) {
                highest_pidwork = pidwork;
            }
            if (lowest_pidwork > pidwork) {
                lowest_pidwork = pidwork;
            }
            pidwork_buffer[pidwork_idx] = pidwork;
            pidwork_idx = (pidwork_idx + 1) & PIDWORK_BUFFER_SIZE;
        }
        pidwork = 0;
    /* os_surrender_context(); */
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void uart_consumer

(

void

)

Definition at line 79 of file test-os.c.

References GPIO_PIN_1, GPIO_PIN_2, GPIO_PIN_3, GPIO_PORTF_BASE, GPIOPinRead(), GPIOPinWrite(), UART0_BASE, uart_consumer_idx, uart_fifo, UART_FIFO_SIZE, uart_producer_idx, and UARTCharPut().

                         {

    while (1) {
        while (((uart_consumer_idx+1) & UART_FIFO_SIZE) != uart_producer_idx) {

            uart_consumer_idx = (uart_consumer_idx+1) & UART_FIFO_SIZE;
            GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3,
                         GPIO_PIN_3 ^ GPIOPinRead(GPIO_PORTF_BASE, GPIO_PIN_3));
            UARTCharPut(UART0_BASE, uart_fifo[uart_consumer_idx]);
        }
    }
}

Here is the call graph for this function:

Variable Documentation

volatile uint32_t highest_pidwork

Definition at line 35 of file test-os.c.

Referenced by main(), and Thread2().

volatile uint32_t lowest_pidwork

Definition at line 36 of file test-os.c.

Referenced by main(), and Thread2().

volatile uint32_t pidwork

Definition at line 34 of file test-os.c.

Referenced by main(), Thread1(), and Thread2().

volatile uint32_t* pidwork_buffer

Definition at line 38 of file test-os.c.

Referenced by main(), and Thread2().

volatile uint32_t pidwork_idx

Definition at line 37 of file test-os.c.

Referenced by main(), and Thread2().

volatile uint32_t uart_consumer_idx

Definition at line 41 of file test-os.c.

Referenced by uart_consumer().

volatile uint32_t uart_dropped_chars

Definition at line 43 of file test-os.c.

volatile char* uart_fifo

Definition at line 42 of file test-os.c.

Referenced by uart_consumer().

volatile uint32_t uart_producer_idx

Definition at line 40 of file test-os.c.

Referenced by uart_consumer().