Rev 902 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed
/***************************************************************************** Copyright (C) 2009-2010 by Claas Anders "CaScAdE" Rathje ** admiralcascade@gmail.com ** Project-URL: http://www.mylifesucks.de/oss/c-strom/ ** ** This program is free software; you can redistribute it and/or modify ** it under the terms of the GNU General Public License as published by ** the Free Software Foundation; either version 2 of the License. ** ** This program is distributed in the hope that it will be useful, ** but WITHOUT ANY WARRANTY; without even the implied warranty of ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ** GNU General Public License for more details. ** ** You should have received a copy of the GNU General Public License ** along with this program; if not, write to the ** Free Software Foundation, Inc., ** 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. ** ** Thanks to: ** Klaus "akku" Buettner for the hardware ** All people at http://www.rn-wissen.de especially for the i2c stuff ** *****************************************************************************/#include <avr/io.h>#include <avr/eeprom.h>#include <avr/pgmspace.h>#include <avr/interrupt.h>#include <util/delay.h>#include <stdlib.h>#include <string.h>#include "C-Strom.h"#include "spi_union.h"#include "i2c_slave.h"uint8_t EEMEM ee_checkbyte1 = CHECKBYTE1;uint8_t EEMEM ee_checkbyte2 = CHECKBYTE2;uint16_t EEMEM ee_cal_ampere = 512;uint8_t EEMEM ee_sensor = 50;uint8_t EEMEM ee_prim_r1 = 47, ee_prim_r2 = 150;uint8_t EEMEM ee_anin_r1 = 47, ee_anin_r2 = 150;uint8_t EEMEM ee_config = 0;volatile uint8_t CSTROM_FLAGS = 0;volatile uint8_t CSTROM_CONFIG = 0;// we could use ee_cal_ampere but eeprom is slow :)volatile uint16_t cal_ampere = 512;volatile uint8_t sensor = 50;volatile uint8_t prim_r1 = 47, prim_r2 = 150;volatile uint8_t anin_r1 = 47, anin_r2 = 150;volatile int16_t ampere, volt, anin_volt, transfer_ampere;volatile int32_t transfer_mah, mah;volatile int16_t average_ampere = 0;volatile uint8_t hwver = 10;// global space for int conversion to stringchar s[10];// spi bufferunion SPI_buffer_t SPI_buffer;// PD7 Highvoid PD7_H() {PORTD |= (1 << PD7);}// PD7 Lowvoid PD7_L() {PORTD &= ~(1 << PD7);}void (*LED_ON)(void) = PD7_H;void (*LED_OFF)(void) = PD7_L;void ampere_calibrate();void save_eeprom();void help(uint8_t);/*ISR(__vector_default) {asm("nop");}*//*** decimal itoa for 10th values*/char *itoa_dec(int val, char* s) {itoa(val, s, 10);//char x = 0;for (uint8_t i = 0; i < 9; i++) {if (s[i] == 0 && i > 0) {if (i == 1) {s[i+1] = s[i-1];s[i-1] = '0';s[i] = '.';s[i+2] = 0;} else {s[i] = s[i-1];s[i-1] = '.';s[i+1] = 0;}break;}}return s;}/*** init uart*/void uart_init() {UBRRL = (F_CPU / (16UL * BAUD_RATE)) - 1;// Enable receiver and transmitter; enable RX interruptUCSRB = (1 << RXEN) | (1 << TXEN) | (1 << RXCIE);//asynchronous 8N1UCSRC = (1 << URSEL) | (3 << UCSZ0);}/*** send a single <character> through uart*/void uart_putc(unsigned char character) {// wait until UDR readywhile (!(UCSRA & (1 << UDRE)));UDR = character;}/*** send a <string> throught uart*/void uart_puts(char *s) {while (*s) {uart_putc(*s);s++;}}/*** send a <string> from pgm space throught uart*/void uart_puts_pgm(char *string) {while (pgm_read_byte(string) != 0x00)uart_putc(pgm_read_byte(string++));}/*** change the sensor type*/void sensor_change(uint8_t new_value) {if (new_value < 10) new_value = 0;else if (new_value > 250) new_value = 250;sensor = new_value;uart_puts_pgm(PSTR("\r\nSensor is now: "));uart_puts(itoa(sensor, s, 10));uart_puts("A\r\n");}/*** change the r2 value*/void r2_change(uint8_t which, uint8_t new_value) {if (which == V_ANIN) {uart_puts_pgm(PSTR("\r\nANIN R2 is now: "));anin_r2 = new_value;uart_puts(itoa_dec(anin_r2, s));} else {uart_puts_pgm(PSTR("\r\nPRIMARY R2 is now: "));prim_r2 = new_value;uart_puts(itoa_dec(prim_r2, s));}uart_puts_pgm(PSTR("kOhm\r\n"));}/*** enable/disable TWI*/void twi_change() {uart_puts_pgm(PSTR("\r\nTWI turned "));if (CSTROM_CONFIG & CSTROM_TWI) {uart_puts_pgm(PSTR("ON"));} else {uart_puts_pgm(PSTR("OFF"));}uart_puts_pgm(PSTR(". Please restart...\r\n"));}/*** Interrupt handler for received data through UART1*/SIGNAL(SIG_UART_RECV) {unsigned char c = UDR;switch (c) {case 'c':ampere_calibrate();break;case 's':save_eeprom();break;case '+':sensor_change(100);break;case '-':sensor_change(50);break;case 'e':if (hwver == 11) r2_change(V_ANIN, anin_r2 + 1);break;case 'd':if (hwver == 11) r2_change(V_ANIN, anin_r2 - 1);break;case 'r':r2_change(V_PRIMARY, prim_r2 + 1);break;case 'f':r2_change(V_PRIMARY, prim_r2 - 1);break;case 'T':CSTROM_CONFIG ^= CSTROM_TWI;twi_change();break;case 'h':help(0);break;default:asm("nop"); // :-)}}/*** Interrupt handler for transmitting data through UART1*/SIGNAL(SIG_UART_TRANS) {}/*** Read out the ADC channel <channel>*/uint16_t readADC(uint8_t channel) {uint8_t i;uint16_t result = 0;// enable ADC and set clk div to 64ADCSRA = (1<<ADEN) | (1<<ADPS2) | (1<<ADPS1);_delay_us(5);// set up channelADMUX = channel;// use internal reference//ADMUX |= (1<<REFS1) | (1<<REFS0);// init ADC for a dummy readoutADCSRA |= (1<<ADSC);// wait for conversion to be completewhile(ADCSRA & (1<<ADSC));// read in three times and get the averagefor(i=0; i<3; i++) {// start conversionADCSRA |= (1<<ADSC);// wait for conversion to be completewhile(ADCSRA & (1<<ADSC));// add up resultresult += ADCW;}// disable ADCADCSRA &= ~(1<<ADEN);// get averageresult /= 3;return result;}/*** init SPI slave interrupt conrolled*/void Init_Slave_IntContr (void) {volatile char IOReg;// Set PB4(MISO) as outputDDRB = (1<<PB4);// MOSI PullupPORTB |= _BV(3);// Enable SPI Interrupt and SPI in Slave ModeSPCR = (1<<SPIE)|(1<<SPE);IOReg = SPSR; // Clear SPIF bit in SPSRIOReg = SPDR;SPCR |= _BV(SPIE); // duplicated}/*** SPI interrupt handling*/ISR(SPI_STC_vect) {LED_ON();unsigned char foo;foo = SPDR;//uart_putc(foo);switch (foo) {case 'A': // requested ampere high bits for next transmissionCSTROM_FLAGS |= CSTROM_SPILOCKED;foo = SPI_buffer.buffer.c[0];break;case 'B': // requested low bitsfoo = SPI_buffer.buffer.c[1];break;case 'C': // wasted ampere high bits in nextfoo = SPI_buffer.buffer.c[2];break;case 'D': // 2nd highest 8bitsfoo = SPI_buffer.buffer.c[3];break;case 'E': // 3rd highest 8bitsfoo = SPI_buffer.buffer.c[4];break;case 'F': // lowest 8bitsfoo = SPI_buffer.buffer.c[5];break;case 'G': // lowest 8bitsfoo = SPI_buffer.buffer.c[6];break;case 'H': // lowest 8bitsfoo = SPI_buffer.buffer.c[7];break;case 'I': // challange overfoo = 'd'; // done :)CSTROM_FLAGS &= ~CSTROM_SPILOCKED;break;default: // what else? nothin nowfoo = 'X';}// write back foo in next transmissionSPDR = foo;//uart_putc(foo);LED_OFF();}/*** read data saved in eeprom*/void get_eeprom() {if (eeprom_read_byte(&ee_checkbyte1) == CHECKBYTE1 && eeprom_read_byte(&ee_checkbyte2) == CHECKBYTE2) {uart_puts("\tLoading data from eeprom...");sensor = eeprom_read_byte(&ee_sensor);cal_ampere = eeprom_read_word(&ee_cal_ampere);anin_r1 = eeprom_read_byte(&ee_anin_r1);anin_r2 = eeprom_read_byte(&ee_anin_r2);prim_r1 = eeprom_read_byte(&ee_prim_r1);prim_r2 = eeprom_read_byte(&ee_prim_r2);CSTROM_CONFIG = eeprom_read_byte(&ee_config);uart_puts("done\r\n");} else {uart_puts("\tNo data found in eeprom, using default data...\r\n");}}/*** save data to eeprom*/void save_eeprom() {uart_puts("\r\nSaving data to eeprom...");eeprom_write_byte(&ee_checkbyte1, CHECKBYTE1);eeprom_write_byte(&ee_checkbyte2, CHECKBYTE2);eeprom_write_byte(&ee_sensor, sensor);eeprom_write_word(&ee_cal_ampere, cal_ampere);//if (hwver == 11) {// why not saving when not needed, there is spaceeeprom_write_byte(&ee_anin_r1, anin_r1);eeprom_write_byte(&ee_anin_r2, anin_r2);//}eeprom_write_byte(&ee_prim_r1, prim_r1);eeprom_write_byte(&ee_prim_r2, prim_r2);eeprom_write_byte(&ee_config, CSTROM_CONFIG);uart_puts("done\r\n");}/*** calibrate the current sensor... has to be 0A during this time!*/void ampere_calibrate() {cli();uart_puts("\r\nCalibrating...");uint16_t temp_cal = 0;for (uint8_t i = 0; i < 10; i++) {temp_cal += readADC(0);uart_puts("#");_delay_ms(100);}cal_ampere = temp_cal / 10;uart_puts("done. Offset is now: ");uart_puts(itoa(cal_ampere, s, 10));uart_puts("\r\n");sei();}volatile uint16_t timer = 0, cs = 0;/*** init timer0*/void init_timer0(void){// set up timerTCCR0 |= (1 << CS00) | (1 << CS01); // timer0 prescaler 64TIMSK |= (1 << TOIE0); // enable overflow timer0}/*** timer overflow handler, should be 1ms*/SIGNAL(SIG_OVERFLOW0) {TCNT0 = 131; // preloadtimer++;// this should be 100msif (timer == 100) {timer = 0;cs++;average_ampere += ampere;CSTROM_FLAGS |= CSTROM_WRITEUART;}// this should be 1sif (cs == 10) {cs = 0;mah += average_ampere / 360;average_ampere = 0;}}/*** write <len> through uart spaces*/void write_space(uint8_t len) {while (len--) {uart_putc(' ');}}/*** check which hardware version we have here*/void check_hw() {// check if pin was output and has pullupuint8_t old_DDRD7 = DDRD & (1 << PD7);uint8_t old_PORTD7 = PORTD & (1 << PD7);// if it was, make it inputif (old_DDRD7) DDRD &= ~(1 << PD7); // PD7 input (LED)if (!old_PORTD7) PORTD |= (1 << PD7); // PD7 enable pullup (LED)if (PIND & (1 << PD7)) {hwver = 11;LED_ON = PD7_L;LED_OFF = PD7_H;}// output againif (!old_PORTD7) PORTD &= ~(1 << PD7); // PD7 disable pullup (LED)if (old_DDRD7) DDRD |= (1 << PD7); // PD7 output (LED)}/*** call for help whenever needed*/void help(uint8_t load) {uart_puts_pgm(PSTR("\r\nC-STROM\r\n\tBUILD: "));uart_puts_pgm(PSTR(BUILDDATE));uart_puts("\r\n\tHW: ");uart_puts(itoa_dec(hwver, s));uart_puts("\r\n");if (load) get_eeprom();uart_puts_pgm(PSTR("\tSensor: "));uart_puts(itoa(sensor, s, 10));uart_puts_pgm(PSTR("A\tCalibration: "));uart_puts(itoa(cal_ampere, s, 10));uart_puts_pgm(PSTR("\r\n\tTWI is "));if (CSTROM_CONFIG & CSTROM_TWI) {uart_puts_pgm(PSTR("ON, SPI may not work!!!"));} else {uart_puts_pgm(PSTR("OFF"));}uart_puts_pgm(PSTR("\r\n\tPIMARY R2: "));uart_puts(itoa_dec(prim_r2, s));if (hwver == 11) {uart_puts_pgm(PSTR("kOhm"));uart_puts_pgm(PSTR("\tANIN R2: "));uart_puts(itoa_dec(anin_r2, s));}uart_puts_pgm(PSTR("kOhm\r\n"));uart_puts_pgm(PSTR("\tCommands available:\r\n"));uart_puts_pgm(PSTR("\t\th : help on commands (this)\r\n"));uart_puts_pgm(PSTR("\t\tc : calibrate ampere\r\n"));uart_puts_pgm(PSTR("\t\tT : toggle TWI (may break SPI communication!)\r\n"));uart_puts_pgm(PSTR("\t\t+/- : to change sensor\r\n"));uart_puts_pgm(PSTR("\t\tr/f : to change PRIMARY-R2 Value\r\n"));if (hwver == 11) {uart_puts_pgm(PSTR("\t\te/d : to change ANIN-R2 Value\r\n"));}uart_puts_pgm(PSTR("\t\ts : save values\r\n"));uart_puts_pgm(PSTR("\tnow enjoy it and have fun...\r\n\r\n"));}/*** Main*/int main (void) {DDRD |= (1 << PD7); // PD7 output (LED)check_hw();uart_init();Init_Slave_IntContr();init_timer0();sei(); // Enable Global Interruptsuart_puts("\x1B[2J\x1B[H"); // clear serialhelp(1);if (CSTROM_CONFIG & CSTROM_TWI) init_twi_slave(CSTROM_I2C);int16_t raw_volt = 0, raw_ampere = 0, raw_aninvolt = 0;char c[10] = " ";c[9] = 0;//strom_data = *((SPI_strom_data_t*) &spi_buffer);//*spi_buffer = *((uint8_t*) (void*) &strom_data);LED_ON();while (1) { // Loop Forever// we have got a normal voltage measuring circuit that takes the lipo-voltageraw_volt = readADC(1);/* according to what i read about voltage divider it isUo = Ue * (R1 / (R2 + R1))Ue = Uo * (R2 + R1) / R1the board has got r1 = 4.7k and r2 = 15kbut since 1step is 0,0048828125V = 4,8828125mV and not 5mV thereis some conversion to do for raw_volt --**-> Uothis should end up in 10th of volts */raw_volt = ((uint32_t)raw_volt * (uint32_t)48828) / (uint32_t)10000;volt = (int16_t) (((uint32_t)raw_volt * (uint32_t)(prim_r1 + prim_r2)) / (uint32_t)prim_r1) / 100;if (volt < 0) volt = 0;// and we have got a seccond voltage measuring circuit for user voltagesraw_aninvolt = readADC(2);/* some conversion to do for raw_volt --**-> Uothis should end up in 10th of volts */raw_aninvolt = ((uint32_t)raw_aninvolt * (uint32_t)48828) / (uint32_t)10000;anin_volt = (int16_t) (((uint32_t)raw_aninvolt * (uint32_t)(anin_r1 + anin_r2)) / (uint32_t)anin_r1) / 100;if (anin_volt < 0) anin_volt = 0;raw_ampere = readADC(0);/* according to datasheet sensitivity is nominal 40mV per A for the 50A chipthis would mean 50A ^= 2V since 0A is set to 2.5V output Voltage we geta range of 0.5V till 4.5V for the full range.the atmega ADC features 0...5V range divided into 10bit ^= 1024 stepsso 0,0048828125V, or 4,8828125mV, is one stepthis leads us to 0,8192 steps per 0,1A and somehow the below formulaand i know that 32bit is evil, but what else does this device has to do? :)this should end up in 100th of ampere */ampere = (int16_t) (((int32_t)(((int16_t)raw_ampere - (int16_t)cal_ampere)) * (int32_t)10000) / (int32_t) 819);if (sensor == 100) ampere *= 2;if ((CSTROM_FLAGS & CSTROM_WRITEUART)) {uart_puts("V: ");uart_puts(itoa_dec(volt, s));write_space(10-strlen(s));uart_puts("AN-IN V: ");uart_puts(itoa_dec(anin_volt, s));write_space(10-strlen(s));uart_puts("A: ");uart_puts(itoa(ampere, s, 10));write_space(10-strlen(s));uart_puts("C: ");uart_puts(itoa(mah, s, 10));write_space(10-strlen(s));uart_puts("\r");CSTROM_FLAGS &= ~CSTROM_WRITEUART;}//spi_buffif (!(CSTROM_FLAGS & CSTROM_SPILOCKED)) {// TESTTINGif (!(CSTROM_CONFIG & CSTROM_TWI)) CSTROM_FLAGS |= CSTROM_SPILOCKED;SPI_buffer.data.ampere = ampere;SPI_buffer.data.mah = mah;if (hwver == 11) {SPI_buffer.data.volt = anin_volt;} else {SPI_buffer.data.volt = volt;}}}return 0;}