Electric_Skateboard_Main_Board.c

//===================================================================================================================
//                                                                      CODE FOR THE SKATEBOARD
//===================================================================================================================

#include <stdio.h>
#include <stdlib.h>
#include "stm32f10x.h"
#include "system_stm32f10x.h"
#include "GPIO_Driver.h"
#include "NRF_Driver.h"
#include "delay.h"
#include "Servo_Driver.h"

#define NUM_LEDS 39 //you must add 1 to how many existing LED's you have.
                                      //For example, if you have 5 LEDs, put 6 for this number.
                                      //I implemented this because sometimes, a bit or two would bleed
                                      //into the next LED, causing it to light up green when the user did not want
                                      //to. This causes that last LED to deliberatly be set to zero.

#define RX_PIPE 1
#define ADDR_HIGH 0xAABBCCDD
#define ADDR_LOW 0xEE
#define EN_D_PL_W 1
#define EN_AUTO_ACK 1
#define PL_W 3
#define CHANNEL 0x7B

void init_PWM_TIM4(void); //neopixels
void TIM4_IRQHandler(void);
void strip_fill(uint32_t R, uint32_t G, uint32_t B, int start, int END);
void strip_show(void);
void strip_run(void);
void strip_rainbow(void);
void strip_fade(void);
void strip_clear(void);
void strip_ASU(void);

uint16_t map(uint16_t var, uint16_t var_low, uint16_t var_high, uint16_t low_thresh, uint16_t high_thresh);

volatile static uint16_t pwm_duty_cicle_neopixels = 0;
volatile static int currentLED = 0;
volatile static int currentRGB = 0;
volatile static int resetFlag = 0;


int static neoPixelBuffer[NUM_LEDS][24]; //this global 2D array appears in the TIM4_IRQHandler and
                                                                                 //the strip_fill function.

int main()
{
    //RX MODE
    uint8_t dataBuffer[4] = {240, 0, 0, 0};
    uint16_t servo_microseconds = 1100;
    uint16_t nrf_disconnection_counter = 0; //if this variable overflows, then
                                                                             //the program knows that the user
                                                                             //has lost connection with the board
                                         //and will stop the board automatically

    //==========================================
    GPIO_TYPE PWM_Output_Neopixels;
    PWM_Output_Neopixels.port = PORTB;
    PWM_Output_Neopixels.pin = 9;
    PWM_Output_Neopixels.mode = OUTPUT;
    PWM_Output_Neopixels.mode_type = OUTPUT_ALT_FUNCTION;
    PWM_Output_Neopixels.speed = SPEED_50MHZ;
    //==========================================

    init_gpio(PWM_Output_Neopixels);
    servo_init(3, 4); //this inits a pwm signal (50hz) on timer 3 channel 4

    init_delay();
    init_PWM_TIM4();

    nrf_init_pins(PORTA, 0, PORTA, 1); //these are the CE and CSN pins on the NRF module
    nrf_init_reciever(RX_PIPE, ADDR_HIGH, ADDR_LOW, CHANNEL, EN_AUTO_ACK, EN_D_PL_W, 32);
    nrf_cmd_act_as_RX();
    nrf_cmd_listen();

    while(1)
    {
        //RX MODE


        if(nrf_data_available())
        {
            nrf_disconnection_counter = 0; //getting into this if statement means that
                                                                    //the nrf module has a connection and
                                                                    //the nrf_disconnection_counter is reset
            nrf_read(dataBuffer);
            servo_microseconds = map(dataBuffer[1], 0, 255, 1100, 2000);
        }
        else
        {
            nrf_disconnection_counter += 1; //increment the nrf_disconnection_counter by 1. If the nrf module
                                                                     //has had no connection for around 1 second, then the
                                                                     //servo_microseconds variable is set to a value that
                                                                     //will slowly stop the skateboard.
            if(nrf_disconnection_counter > 100)
            {
                servo_microseconds = 1100;
                nrf_disconnection_counter = 0;

            }
        }
        delayMs(10);

        if(dataBuffer[3] != 1)
        {
            servo_writeMicroseconds(servo_microseconds, 3, 4);
        }
        else
        {
            servo_writeMicroseconds(1000, 3, 4);
        }


        if(play_millis(100*1000) == 0) //this play_millis function equals 0 after the user identified time (in us)
                                                                     //has past. It will stay zero until the play_millis function is called again
        {
            switch(dataBuffer[2])
            {
                case 0:
                    strip_fill(150, 0, 0, 0, NUM_LEDS); //RED
                    strip_show();
                break;

                case 1:
                    strip_fill(0, 150, 0, 0, NUM_LEDS); //GREEN
                    strip_show();
                break;

                case 2:
                    strip_fill(0, 0, 150, 0, NUM_LEDS); //BLUE
                    strip_show();
                break;

                case 3:
                    strip_fill(150, 0, 150, 0, NUM_LEDS); //PURPLE
                    strip_show();
                break;

                case 4:
                    strip_fill(150, 30, 0, 0, NUM_LEDS); //ORANGE
                    strip_show();
                break;

                case 5:
                    strip_fill(150, 150, 150, 0, NUM_LEDS); //WHITE
                    strip_show();
                break;

                case 6:
                    strip_ASU();
                break;

                case 7:
                    strip_fade();
                break;

                case 8:
                    strip_run();
                break;

                case 9:
                    strip_rainbow();
                break;

                case 10:
                    strip_clear(); //turn LEDS off
                break;

            }
        }
    }
}


//This interupt service routine starts when strip_show is called
//and produces the correct PWM signal to make the correct color that was specified
//in the strip_fill function.
void TIM4_IRQHandler()
{
    if(TIM4->SR & TIM_SR_UIF)
    {
        TIM4->SR &= ~(TIM_SR_UIF);

        if(resetFlag != 1)
        {
            if(neoPixelBuffer[currentLED][currentRGB] == 1 )
            {
                pwm_duty_cicle_neopixels = 57; //creats a high pulse to satisfy the neopixels timing requirement for a 1
            }
            else
            {
                pwm_duty_cicle_neopixels = 27; //creats a high pulse to satisfy the neopixels timing requirement for a 0
            }
            currentRGB++;
            TIM4->CCR4 = pwm_duty_cicle_neopixels;

            if(currentRGB>23) //the neopixel needs 24 bits for the color. 8 for red, 8 for green, 8 for blue
            {                                   //once it has completed an etire color, it will move on to the next LED
                currentRGB = 0;
                currentLED++;
            }
        }
        resetFlag = 0;
        TIM4->ARR = 700;
    }
}


//this function "maps" the values from a given varibale, the range of values that that variable has,
//and will return a new proportional value in the range of the users choice
uint16_t map(uint16_t var, uint16_t var_low, uint16_t var_high, uint16_t low_thresh, uint16_t high_thresh)
{
    return (var -  var_low)*(high_thresh - low_thresh)/(var_high - var_low) + low_thresh;
}

void init_PWM_TIM4(void)
{
    //init timer and alternate function
    RCC->APB1ENR |= RCC_APB1ENR_TIM4EN;
    RCC->APB2ENR |= RCC_APB2ENR_AFIOEN;

    //init the ARR
    TIM4->CR1 |= TIM_CR1_ARPE;

    //init interrupts
    TIM4->CR1 |= TIM_CR1_URS;

    //update interrupt enable
    TIM4->DIER |= TIM_DIER_UIE;

    //tell the NVIC to listen to interupts on the timer 4 IRQ number
    NVIC_EnableIRQ(TIM4_IRQn);

    //enable PWM mode 1 and the preloader
    TIM4->CCMR2 |= TIM_CCMR2_OC4M_1 | TIM_CCMR2_OC4M_2 | TIM_CCMR2_OC4PE;

    //PWM DC = CRR4/ARR
    //enable duty cycle
    TIM4->PSC = 0;
    TIM4->ARR = 700; //this value must generate a frequency no larger than the reset time of the neopixel(see datasheet)
    TIM4->CCR4 = pwm_duty_cicle_neopixels;

    //enable the update generation
    TIM4->EGR |= TIM_EGR_UG;
}

//The strip_fill funcion lights up the LEDs in the desired range.
//For example, if you want the first 3 LEDs to be green, you would
//say strip_fill(0, 255, 0, 0, 3).
void strip_fill(uint32_t R, uint32_t G, uint32_t B, int start, int END)
{
  uint32_t grb = B | (R << 8) | (G << 16);

    if(END > NUM_LEDS) //if the user accidently inputs an end value that is higher than the
    {                                    //NUM_LEDS macro, then END will be set to NUM_LEDS
        END = NUM_LEDS;
    }

  for(int j = start; j < END; j++)
  {
    for(int i = 0; i < 24; i++)
    {
      if( ((grb >> i) & 0x01) == 1)
      {
        neoPixelBuffer[j][23-i] = 1;
      }
      else
      {
        neoPixelBuffer[j][23-i] = 0;
      }
    }
  }
}

void strip_show()
{
    resetFlag = 1; //set reset flag so the function inside the interrupt isn't used

    TIM4->ARR = 6000; //set the ARR to a value that satisfies the data sheet of a low time of at most 50uS(+50us = reset command)
    TIM4->CCR4 = 0; //set the pwm signal to low

    TIM4->CCER |= TIM_CCER_CC4E; //turn on pwm channel 4
    TIM4->CR1 |= TIM_CR1_CEN; //turn on timer

    while(currentLED < NUM_LEDS); //wait until all the LEDS are set

    TIM4->CCER &= ~(TIM_CCER_CC4E); //turn off channel 4
    TIM4->CR1 &= ~(TIM_CR1_CEN); //turn off timer

    currentLED = 0;
    currentRGB = 0;

}

//lights up the first half of LEDs red, and the other half yellow
void strip_ASU()
{
    strip_clear();
    strip_fill(150, 0, 0, 0, NUM_LEDS/2);
    strip_fill(150, 75, 0, NUM_LEDS/2, NUM_LEDS);
    strip_show();
}

//fades the LEDs from color to color
void strip_fade()
{
    static uint8_t currentColor = 2;
    static uint8_t currentColorCount = 0;

    if(currentColor > 150)
    {
        currentColor = 150;
        currentColorCount++;
    }
    else if(currentColor < 2)
    {
        currentColor = 2;
        currentColorCount++;
    }

    if(currentColorCount > 5)
    {
        currentColorCount = 0;
    }

    if(currentColorCount == 0)
    {
        currentColor+=2;
        strip_fill(150, currentColor, 0, 0, NUM_LEDS);
    }
    else if(currentColorCount == 1)
    {
        currentColor-=2;
        strip_fill(currentColor, 150, 0, 0, NUM_LEDS);
    }
    else if(currentColorCount == 2)
    {
        currentColor+=2;
        strip_fill(0, 150, currentColor, 0, NUM_LEDS);
    }
    else if(currentColorCount == 3)
    {
        currentColor-=2;
        strip_fill(0, currentColor, 150, 0, NUM_LEDS);
    }
    else if(currentColorCount == 4)
    {
        currentColor+=2;
        strip_fill(currentColor, 0, 150, 0, NUM_LEDS);
    }
    else if(currentColorCount == 5)
    {
        currentColor-=2;
        strip_fill(150, 0, currentColor, 0, NUM_LEDS);
    }
    strip_show();

}

//changes a single LED at a time on one half while changing the other half to a different color at a time.
//this creates what looks like to be a "running" annimation of the LEDs
void strip_run()
{
    static uint8_t runCount = 0;
    static uint8_t colorCount = 0;

    runCount++;

    if(runCount > (NUM_LEDS/2))
    {
        runCount = 1;
        colorCount++;
    }
    if(colorCount > 2)
        colorCount = 0;

    if(colorCount == 0)
    {
        strip_fill(75, 0, 150, NUM_LEDS-runCount, NUM_LEDS);
        strip_fill(0, 150, 0, 0, runCount);
    }
    else if(colorCount == 1)
    {
        strip_fill(150, 75, 0, NUM_LEDS-runCount, NUM_LEDS);
        strip_fill(0, 75, 150, 0, runCount);
    }
    else if(colorCount == 2)
    {
        strip_fill(150, 150, 150, NUM_LEDS-runCount, NUM_LEDS);
        strip_fill(150, 0, 0, 0, runCount);
    }

    strip_show();

}

//creates a plain rainbow effect to the LEDs (this function is proportional to the amount of LEDs present,
//therefor you can change the amount of leds and not have to worry about messing up this animation)
void strip_rainbow()
{
    const uint8_t colorOffset = (NUM_LEDS/9)+1;

    static uint8_t led_start = 0;
    static uint8_t led_finish = 0;

    led_start = 0;
    led_finish = 0;

    led_finish = led_finish + colorOffset;

    strip_fill(150,0,0,led_start,led_finish);

    led_start = led_finish;
    led_finish = led_finish + colorOffset;

    strip_fill(150,37,0,led_start, led_finish);

    led_start = led_finish;
    led_finish = led_finish + colorOffset;

    strip_fill(150, 112, 0, led_start, led_finish);

    led_start = led_finish;
    led_finish = led_finish + colorOffset;

    strip_fill(0,150,0,led_start,led_finish);

    led_start = led_finish;
    led_finish = led_finish + colorOffset;

    strip_fill(0,75,150,led_start, led_finish);

    led_start = led_finish;
    led_finish = led_finish + colorOffset;

    strip_fill(0, 0, 150, led_start, led_finish);

    led_start = led_finish;
    led_finish = led_finish + colorOffset;

    strip_fill(75,0,150,led_start,led_finish);

    led_start = led_finish;
    led_finish = led_finish + colorOffset;

    strip_fill(150,0,150,led_start, led_finish);

    strip_show();
}


//sets the LEDs to no color. Be careful, even though the LEDs are off, the neopixels still draw current
//because they are doing work to send zeros across each other.
void strip_clear()
{
    strip_fill(0,0,0,0,NUM_LEDS);
}