bikegenerator/schaltungen/displayboard_servo/software/src/main.c

#include <stdlib.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <util/delay.h>
#include <string.h>
#include "utils.h"
#include "main.h"
#include "uart.h"


#define BUFSIZE		32

volatile uint16_t syscounter = 0;

// values send over uart from powerboard
typedef struct {
	uint16_t voltage_gen;
	uint16_t voltage_reg;
	uint16_t current_gen;
	
	struct {
		uint8_t loadsw : 1;
		uint8_t gensw : 1;
		uint8_t batsw : 1;
	};
} PWR_DATA;

static PWR_DATA pd;

uint8_t data_count = 0;
char data_in[BUFSIZE];
extern unsigned char __heap_start;
   
   
static void timer_init(void) {
	// clock is 8MHz
	TCCR1B |= _BV(WGM12) | _BV(CS11) | _BV(CS10);       // CTC Mode for Timer 1 (16Bit) with prescale of 64
    OCR1A = 2312;                           // Neutralposition ((2500-2312)*0.008ms)=1,5ms)
	TIMSK = _BV(OCIE1A);
	TCCR1A = (1<<COM1A0);                   // Togglen bei Compare Match
}

static void ports_init(void) {
	DDRB |= _BV(PB3); 
}

static void process_command(char *command) {
	
    if(command[0] == 'A') {
		// command must be in the following format:
        // A$voltage_gen,$voltage_reg,$current_gen,loadsw,batsw,gensw\n
        // examples: 
        //	A24500,13400,12000,1,1,1B
        //	A19900,11000,15000,1,1,1B
        //	A34100,15100,01000,1,1,1B

        char *token;
        uint8_t tokencounter = 0;

        token = strtok(command, ","); 
        
        while( token ) {
			/*uart_puts_P("\r\ntoken: ");
			uart_puts(token);
			
			uart_puts_P("\r\ntokencounter: ");
			uart_print_uint16(tokencounter);*/
			
            switch(tokencounter) {
                case 0:
                    pd.voltage_gen = atoi(++token);	// skip the A in front of the number
                    break;
                case 1:
                    pd.voltage_reg = atoi(token);
                    break;
                case 2:
                    pd.current_gen = atoi(token);
                    break;
                case 3:
                    if(atoi(token) == 1) pd.loadsw = 1;
                    else pd.loadsw = 0;
                    break;
                case 4:
                    if(atoi(token) == 1) pd.batsw = 1;
                    else pd.batsw = 0;
                    break;
                case 5:
                    if(atoi(token) == 1) pd.gensw = 1;
                    else pd.gensw = 0;
                    break;
            }

            tokencounter++;
            token = strtok(NULL, ",");
        }
    }
}

static void work_uart() {

    uint16_t c = uart_getc();

    if ( !(c & UART_NO_DATA) ) {
		
		data_in[data_count] = (c & 0xff);
		
		/*
		uart_print_uint16(data_count);
		uart_puts_P(" char: ");
		uart_putc(c >> 8);
		uart_putc(c & 0xff);
		uart_puts_P(";\r\n");
		*/
		/*
		uart_puts_P("data: ");
		
		for(uint8_t i = 0; i < BUFSIZE; i++) {
			uart_putc(data_in[i]);
		}
		uart_puts_P("\r\n");
		*/

        if (data_in[data_count] == 'B') {
			//uart_puts_P("got b\r\n");
            
            process_command(data_in);
            
            data_count = 0;
            memset(data_in, 0, BUFSIZE);
        } 
        
        data_count++;
		if(data_count >= BUFSIZE) {
			data_count = 0;
			memset(data_in, 0, BUFSIZE);
			//uart_puts_P("overflow\r\n");
		}
        
    }


}

static void set_servo(uint16_t display) {

	if( display < 1 ) display = 1;
	if( display > 400 ) display = 400;

    display = display * 10;   // shift, since we have to divide by 3,2 (32)
    display = display / 32;   // instead of dividing by 3,2
    display = display + 125;

	cli();		// read and write atomic
	if( display < 125 ) display = 125;
	if( display > 250 ) display = 250;
    OCR1A = 2500-display;
    sei();    
}


static void demo_display(void) {
	for(uint16_t i = 0; i<= 40;i++) {
		set_servo(i*10);
		_delay_ms(50);
	}
	for(uint16_t i = 40; i> 0;i--) {
		set_servo(i*10);
		_delay_ms(50);
	}
}


int main(void) {
	sei();
	ports_init();
	timer_init();
    uart_init(UART_BAUD_SELECT(38400,F_CPU));
    memset(data_in, 0, BUFSIZE);
    
	demo_display();

	while(1) {
		
	    work_uart();

        if(syscounter >= 100) {
			memset(data_in, 0, BUFSIZE);
			data_count = 0;
            uart_putc('a'); // send a to receive values
			
			//uart_puts_P("RAM="); uart_print_uint16(SP - (uint16_t) &__heap_start); uart_puts_P("\r\n");
            
            set_servo((pd.voltage_gen/1000) * (pd.current_gen/1000));
            
            /*
            uart_puts_P("voltage_gen = ");
            uart_print_voltage(pd.voltage_gen);
            uart_puts_P(" voltage_reg = ");
            uart_print_voltage(pd.voltage_reg);
            uart_puts_P(" current_gen = ");
            uart_print_current(pd.current_gen);
            uart_puts_P("\r\n");
            */
            syscounter = 0;
        }
	}
	
	return(0);
}

SIGNAL(TIMER1_COMPA_vect) {
	syscounter++;
    OCR1A = 2500-OCR1A;         // Das Servosignal wird aus der Differenz von
                                // Periodenlänge (2500*0,008ms=20ms) und letztem
                                // Vergleichswert (OCR1A) gebildet	
}