Colony

#include "encoders.h" 

#include "spi.h" 

#include <dragonfly_lib.h> 

#include "ring_buffer.h" 

unsigned short int left_data_buf;

unsigned short int right_data_buf;

char buf_index;

unsigned short int left_data;

unsigned short int right_data;

unsigned short int left_data_array[BUFFER_SIZE];

unsigned short int right_data_array[BUFFER_SIZE];

int left_data_idx;

int right_data_idx;

int left_dx;

int right_dx;

long int timecount;

void encoder_recv(char data);

//Helper Function Prototypes

inline void left_data_array_put(unsigned short int value);

inline unsigned short int left_data_array_top(void);

inline unsigned short int left_data_array_prev(void);

inline unsigned short int left_data_array_bottom(void);

inline void right_data_array_put(unsigned short int value);

inline unsigned short int right_data_array_top(void);

inline unsigned short int right_data_array_prev(void);

inline unsigned short int right_data_array_bottom(void);

//RING_BUFFER_NEW(enc_buffer, BUFFER_SIZE, short int);

void encoder_init(void){

        int i;

        spi_init(encoder_recv,NULL);

        buf_index = 0;

        left_data_buf = 0;

        right_data_buf= 0;

        left_data = -1;

        right_data = -1;

        //RING_BUFFER_INIT(enc_buffer,BUFFER_SIZE);

        left_data_idx = 0;

        right_data_idx = 0;

        for(i = 0; i < BUFFER_SIZE; i++) {

                left_data_array[i] = 0;

        }

        for(i = 0; i < BUFFER_SIZE; i++) {

                right_data_array[i] = 0;

        }

}

int encoder_read(char encoder){

        if(encoder==LEFT)

                return left_data;

        else if(encoder==RIGHT)

                return right_data;

        else return -1;

}

int encoder_change(char encoder){

        return 0;

}

char encoder_direction(char encoder){

        return 0;

}

int encoder_get_dx(char encoder) {

        if(encoder==LEFT)

                return left_dx;

        else if(encoder==RIGHT)

                return right_dx;

        else return -1;

}

void encoder_rst_dx(char encoder) {

        if(encoder==LEFT)

                left_dx = 0;

        else if(encoder==RIGHT)

                right_dx = 0;

}

int encoder_get_tc(void) {

        return timecount;

}

void encoder_rst_tc(void) {

        timecount = 0;

}

//Full reads occur every 40 microseconds. This function should be called

//every 8 microseconds.

void encoder_recv(char data){

        short int dx;

        //First two bytes are normal.        

        if(buf_index < 2)

                right_data_buf |= (((short)data) << ((1-buf_index)*8)) & (0xFF<<(1-buf_index));

        //Second two bytes are skewed by one junk bit at the top.         

        else if (buf_index == 2)

                left_data_buf |= (((short)data) << 9) & (0x7F << 9);

        else if (buf_index == 3)

                left_data_buf |= (((short)data) << 1) & (0xFF<<1);

        //Only want the highest bit.        

        else if (buf_index == 4)

                left_data_buf |= (((short)data)>>7) & 0x1;

        buf_index = (buf_index + 1) % 5;

        if(buf_index==0){

                if(left_data_buf & (OCF | COF | LIN)) 

                        left_data = INVALID;

                else if(((left_data_buf & MagINCn) > 0)  && ((left_data_buf & MagDECn) > 0)) 

                        left_data = MAGNET_FAILURE;

                else left_data = (left_data_buf>>5) & 1023;

                if(right_data_buf & (OCF | COF | LIN)) 

                        right_data = INVALID;

                else if ( ((left_data_buf & MagINCn) > 0)  && ((left_data_buf & MagDECn) > 0)) 

                        left_data = MAGNET_FAILURE;

                else right_data = (right_data_buf>>5) & 1023;

                left_data_buf = 0;

                right_data_buf = 0;

        }

        if(left_data < INVALID) {

                //Put new data onto data array

                left_data_array_put(left_data);

                //Adjust left accumulator

                dx = left_data - left_data_array_prev();

                if(dx > 5) { //underflow

                        left_dx += dx - 1023;

                }

                else if(dx < -5) { //overflow

                        left_dx += dx + 1023;

                }

                else {

                        left_dx += dx;

                }

        }

        if(right_data < INVALID) {

                //Put new data onto data array

                right_data_array_put(right_data);

                //Adjust right accumulator

                dx = right_data - right_data_array_prev();

                if(dx > 5) { //underflow

                        right_dx += dx - 1023;

                }

                else if(dx < -5) { //overflow

                        right_dx += dx + 1023;

                }

                else {

                        right_dx += dx;

                }

        }

        //Increment timecount accumulator

        timecount++;

}

//Helper Functions

inline void left_data_array_put(unsigned short int value) {

        if(left_data_idx == BUFFER_SIZE-1)

                left_data_idx = 0;

        else

                left_data_idx++;

        left_data_array[left_data_idx] = value;

}

inline unsigned short int left_data_array_top(void) {

        return left_data_array[left_data_idx];

}

inline unsigned short int left_data_array_prev(void) {

        if(left_data_idx == 0)

                return left_data_array[BUFFER_SIZE-1];

        else

                return left_data_array[left_data_idx - 1];

}

inline unsigned short int left_data_array_bottom(void) {

        if(left_data_idx == BUFFER_SIZE-1)

                return left_data_array[0];

        else

                return left_data_array[left_data_idx + 1];

}

inline void right_data_array_put(unsigned short int value) {

        if(right_data_idx == BUFFER_SIZE-1)

                right_data_idx = 0;

        else

                right_data_idx++;

        right_data_array[right_data_idx] = value;

}

inline unsigned short int right_data_array_top(void) {

        return right_data_array[right_data_idx];

}

inline unsigned short int right_data_array_prev(void) {

        if(right_data_idx == 0)

                return right_data_array[BUFFER_SIZE-1];

        else

                return right_data_array[right_data_idx - 1];

}

inline unsigned short int right_data_array_bottom(void) {

        if(right_data_idx == BUFFER_SIZE-1)

                return right_data_array[0];

        else

                return right_data_array[right_data_idx + 1];

}