Difference between revisions of "Open ReVolt/Software"
From EcoModder Forum Wiki
(Created page with "{{Open ReVolt Header}} [http://svn.fastdigitech.ro/trac/openrevolt/browser/trunk svn repository] (browse only) [http://www.atmel.com/dyn/products/tools_card.asp?tool_id=2725...") |
(No difference)
|
Latest revision as of 17:05, 9 July 2018
The Open ReVolt Project: Wiki main page | Paul's website | Forum thread | Donate
svn repository (browse only)
Current Controller Software--ZeroGasoline 19:44, 21 May 2009 (EDT)
Contents
Software Features and Revisions
An Archive of firmware versions v0.10 through v1.11b is available at :http://www.adambrunette.com/firmware/
- version 0.1 - first version tested
- version 0.2 - added PW (PWM) to realtime data
- version 0.3 - added thermal cutback code (to be checked by Paul)
- version 0.4 - added continous check of vref below 2V
- version 0.5 - declared some variables volatile to enforce execution within bounds of cli() and sei()
- version 0.6 - make ocr1a_lpf time constant longer - V0.5 oscillates if Kp,Ki are low (slow PI loop)
- version 0.7 - fixed stupid bug in config_pi() that caused Joe's problems (thanks Joe)
- version 0.8 - high pedal lockout added but not yet tested
- version 0.9 - store mutiple copies of configuration in EE prom (not yet tested)
- version 0.10 - code size reduction, correct thermal cutback starting point, selectable pwm low pass filter
- version 1.0 - in pi_loop() added cli() and sei() around update of OCR1A, added cli() after pi_loop
- version 1.1 - added battery amps and battery amp hour calculations (not yet tested)
- version 1.2 - added motor overspeed logic (experimental and not yet tested)
- version 1.3 - added battery amps limit (not yet tested) and changed motor overspeed parameters to 4 digit
- version 1.4 - new 8KHz PWM compile to option, added battery_amps_limit, spare, and crc, default_config PROGMEM
- version 1.5 - fixed ocr1a_lpf calculation - so battery amps limit should now work, added "restart" command
- version 1.6 - added support for ATMEGA168 (not yet tested)
- version 1.7 - moved motor overspeed logic (still not yet tested) from main() into interrupt code pi_loop()
- version 1.8 - added precharge timer, removed not needed code that measures pi_loop() execution time
- version 1.9 - forgot to calculate bat_amp_lim_510 when loading config from EEprom, now fixed (thanks Adam)
- version 1.10 - added configurable PWM dead zone and motor overspeed detect time for motor overspeed logic, configuration menu a little nicer, new watchdog handling (mainly for ATMega168)
- 2010-01-10 fixed defines for PIND, DDRD, and PORTD in bootload168/misc.asm (no version change)
- version 1.11 - added motor_speed_calc_amps - attempt to avoid overspeed tripping when pedal is "pumped"
Latest Software (cut and paste into avrstudio):
Create the 3 files listed in AVRStudio and add the code to the associated file.
Cougar.c
/*
firmware for cougar open source DC motor controller
*/
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <avr/interrupt.h>
#include <avr/iom8.h>
#include <util/crc16.h>
#include <avr/wdt.h>
#include <avr/eeprom.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "cougar.h"
// now using automatically generated CRC file
#include "autocrc.h"
typedef struct {
int throttle_ref;
int current_ref;
int current_fb;
unsigned raw_hs_temp;
unsigned raw_throttle;
} realtime_data_type;
typedef struct {
long K1;
long K2;
long error_new;
long error_old;
long pwm;
} pi_storage_type;
typedef struct {
unsigned magic; // must be 0x12ab
int Kp; // PI loop proportional gain
int Ki; // PI loop integreal gain
unsigned throttle_min_raw_counts; // throttle low voltage (pedal to metal)
unsigned throttle_max_raw_counts; // throttle high voltage (foot off pedal)
unsigned throttle_pos_gain; // gain for actual throttle position
unsigned throttle_pwm_gain; // gain for pwm (voltage)
int current_ramp_rate; // current ramp rate
int spare[7]; // spare parameters
unsigned crc; // checksum for verification
} config_type;
config_type default_config PROGMEM = {
0x12ab, // magic
2, // PI loop P gain (Joe's was 1)
160, // PI loop I gain (Joe's was 20)
413, // throttle low voltage (pedal to metal)
683, // throttle high voltage (foot off pedal)
8, // throttle pedal position gain
0, // throttle pwm (voltage) gain
6, // current ramp rate (from throttle)
};
unsigned char counter_16k = 0;
unsigned char counter_8k = 0;
unsigned char counter_4k = 0;
unsigned char ad_channel = 0;
unsigned char oc_cycles_off_counter = 0;
unsigned char in_pi_loop = 0;
volatile unsigned char pi_run_tm = 0;
volatile unsigned counter_1k = 0; // 1KHz (976Hz to be exact) counter for timing
volatile unsigned raw_current_fb; // AD channel 2
volatile unsigned raw_hs_temp; // AD channel 1
volatile unsigned raw_throttle; // AD channel 0
unsigned vref = 0; // zero current voltage for LEM current sensor
unsigned ocr1a_lpf = 0; // ocr1a run through lowpass filter (sort of averaged)
unsigned max_current_ref = MAX_CURRENT_REF; // max_current_ref in variable so controlled by temperature
int throttle_ref = 0; // reference (desired) throttle
int current_ref = 0; // reference (desired) current
int current_fb = 0; // current feedback (actual current)
unsigned long idle_loopcount; // how many loops we do while micro is not executing PI
pi_storage_type pi;
config_type config;
realtime_data_type rt_data;
#ifdef crc_address
// calc CRC for program (firmware)
unsigned int calc_prog_crc(unsigned nbytes)
{
unsigned n, crc;
crc = 0xffff;
for (n = PROGSTART; n < nbytes; n++) {
crc = _crc_ccitt_update (crc, pgm_read_byte(n));
}
return(crc);
}
#endif
// calc CRC on block in SRAM
unsigned int calc_block_crc(unsigned nbytes, unsigned char *buf)
{
unsigned n, crc;
crc = 0xffff;
for (n = 0; n < nbytes; n++) {
crc = _crc_ccitt_update (crc, *(buf + n));
}
return(crc);
}
inline void clear_oc(void)
{
PORTB &= ~PB_OC_CLEAR; // OC clear low (low to clear)
asm("nop"); asm("nop"); // 4 nops = 1/4th uS - enough for 74HC00
asm("nop"); asm("nop");
PORTB |= PB_OC_CLEAR; // OC clear high (high for normal operation)
}
inline unsigned get_time(void)
{
unsigned t;
cli(); t = counter_1k; sei();
return(t);
}
inline unsigned diff_time(unsigned before)
{
unsigned now;
cli(); now = counter_1k; sei();
return(now - before);
}
unsigned long wait_time(unsigned howlong)
{
unsigned begin;
unsigned long loopcount;
loopcount = 0;
begin = get_time();
while (diff_time(begin) < howlong) loopcount++;
return(loopcount);
}
// PI loop code - runs at 4Khz
void pi_loop(void)
{
static unsigned char throttle_counter = 0;
unsigned char entry_tm, exec_tm;
unsigned loc_current_fb, loc_throttle;
unsigned uv1, uv2;
int i;
entry_tm = counter_16k;
loc_current_fb = raw_current_fb;
loc_throttle = raw_throttle;
sei();
// now we have a snapshot of all ADC readings and interrupts are enabled
// the timer 1 overflow ISR should re-enter on itself if it needs to
// we also have a snapshot of the entry time (16KHz counter) so we can measure execution time
// convert loc_current_fb from raw value to scaled (0 to 511)
// current starts in [512, 512 + 213] (if it's in 0 to 500 amps for the LEM 300)
if (loc_current_fb < vref) loc_current_fb = 0;
else loc_current_fb -= vref;
// now current is in the range [0, 213] or so
current_fb = (loc_current_fb * 19) >> 3; // (19/8 is almost 2.4)
// now current is in [0, 506] or so, close to same as current reference range
pi.error_new = current_ref - current_fb;
// execute PI loop
// first, K1 = Kp << 10;
// second, K2 = Ki - K1;
if (current_ref == 0) {
pi.pwm = 0;
//pi.Kp = 0;
//pi.Ki = 0;
// if Kp and Ki = 0, then K1 and K2 = 0;
// if K1 and K2 = 0, then pwm = pwm + 0, and 0 + 0 = 0
// so we don't need to run the PI loop, just set error_old to error_new
}
else {
pi.pwm += (pi.K1 * pi.error_new) + (pi.K2 * pi.error_old);
}
pi.error_old = pi.error_new;
if (pi.pwm > (510L << 16)) pi.pwm = (510L << 16);
else if (pi.pwm < 0L) pi.pwm = 0L;
if (pi.pwm & 0x8000) OCR1A = (pi.pwm >> 16) + 1;
else OCR1A = (pi.pwm >> 16);
// calculate average OCR1A value
// OCR1A max value is 511, so we can multiply it by up to 127 times
ocr1a_lpf = ((ocr1a_lpf * 15) + (unsigned)OCR1A) >> 4;
throttle_counter++;
if ((throttle_counter & 0x03) == 0x00) {
// run throttle logic at 1KHz - calculate throttle_ref
if (loc_throttle > config.throttle_max_raw_counts)
loc_throttle = config.throttle_max_raw_counts;
else if (loc_throttle < config.throttle_min_raw_counts)
loc_throttle = config.throttle_min_raw_counts;
loc_throttle -= config.throttle_min_raw_counts;
// now loc_throttle is in [0, (throttle_max_raw_counts - throttle_min_raw_counts)]
loc_throttle = (config.throttle_max_raw_counts - config.throttle_min_raw_counts) -
loc_throttle;
/*
now, 0 throttle is 0,
and max throttle is (throttle_max_raw_counts - throttle_min_raw_counts)
*/
throttle_ref = (long)loc_throttle * (long)MAX_CURRENT_REF /
(long)(config.throttle_max_raw_counts - config.throttle_min_raw_counts);
// now throttle ref in [0 to 511]
}
else if ((throttle_counter & 0x03) == 0x01) {
// run throttle logic at 1KHz - calculate current_ref from throttle_ref
// throttle gain logic
uv1 = (throttle_ref * config.throttle_pos_gain) >> 8;
uv2 = (throttle_ref * config.throttle_pwm_gain) >> 8;
if (uv1 > uv2) loc_throttle = uv1 - uv2;
else loc_throttle = 0;
// current_ref ramp rate logic
if (loc_throttle > max_current_ref) i = (max_current_ref - current_ref);
else i = (int)loc_throttle - current_ref;
if (i > config.current_ramp_rate) i = config.current_ramp_rate;
else if (i < -config.current_ramp_rate) i = -config.current_ramp_rate;
current_ref += i;
}
// measure how long execution took
exec_tm = counter_16k - entry_tm;
if (exec_tm > pi_run_tm) pi_run_tm = exec_tm;
}
// TIMER1 overflow interrupt
// This occurs center aligned with PWM output - best time to sample current sensor
// Rate is 16KHz
ISR(TIMER1_OVF_vect)
{
unsigned ui;
counter_16k++;
if (counter_16k & 0x01) {
// every other time (8KHz)
counter_8k++;
if (counter_8k & 0x01) {
// conversion on throttle or heatsink done - grab result
ui = ADC;
ADMUX = ADMUX = (1 << REFS0) | 2; // start conversion on current fb chan
ADCSRA = (1 << ADEN) | (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0) | (1 << ADSC);
if (ad_channel == 0) raw_throttle = ui;
else if (ad_channel == 1) raw_hs_temp = ui;
counter_4k++;
if ((counter_4k & 0x03) == 0) counter_1k++; // 1 KHz counter for delays, etc.
// overcurrent trip logic
if (PINB & PINB_OC_STATE) {
// overcurrent circuit tripped
oc_cycles_off_counter++;
}
if (oc_cycles_off_counter >= NUM_OC_CYCLES_OFF) {
// time to reset overcurrent trip circuit
oc_cycles_off_counter = 0;
#ifdef OC_CLEAR_ENABLED
clear_oc();
#endif
}
}
else {
// convertion on current sensor reading complete (4KHz)
raw_current_fb = ADC; // get conversion result
ad_channel++; // next channel channel
if (ad_channel > 1) ad_channel = 0; // wrap around logic
ADMUX = ADMUX = (1 << REFS0) | ad_channel; // set channel and start conversion
ADCSRA = (1 << ADEN) | (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0) | (1 << ADSC);
// execute PI loop with re-entrancy check
if (!in_pi_loop) {
in_pi_loop = 1; pi_loop(); in_pi_loop = 0;
}
}
}
}
// timer 1 input capture ISR (1000 hertz)
SIGNAL(SIG_INPUT_CAPTURE1)
{
counter_1k++; // 1 KHz counter for delays, etc.
}
unsigned char measure_vref(void)
{
unsigned char lp;
unsigned sum;
sum = 0;
for (lp = 0; lp < 16; lp++) {
// do a conversion on channel 2 - current sensor
ADMUX = ADMUX = (1 << REFS0) | 2;
ADCSRA = (1 << ADEN) | (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0) | (1 << ADSC);
while (ADCSRA & (1 << ADSC));
sum += ADC;
}
vref = sum >> 4;
if ((vref > (512 + 50)) || (vref < (512 - 50))) return(0);
return(1);
}
void config_pi(void)
{
/* A couple of points:
We are now doing OCR1A = (pwm >> 16) instead of (pwm >> 15)
Because of this, both Kp and Ki must double for same loop response
Also, the PI loop is run at 4KHz instead of 16, so Ki must quadruple for same loop response
So for same loop response, Kp is 2X and Ki is 8X */
long v1, v2;
v1 = (long)config.Kp << 10;
v2 = (long)config.Ki - pi.K1;
cli(); pi.K1 = v1; pi.K2 = v2; sei();
}
void fetch_rt_data(void)
{
// fetch variable with interrupts off, then re-enable interrupts (interrupts can happen during NOPs)
cli(); rt_data.throttle_ref = (volatile int)throttle_ref; sei();
asm("nop"); asm("nop"); asm("nop"); asm("nop");
// fetch variable with interrupts off, then re-enable interrupts (interrupts can happen during NOPs)
cli(); rt_data.current_ref = (volatile int)current_ref; sei();
asm("nop"); asm("nop"); asm("nop"); asm("nop");
// fetch variable with interrupts off, then re-enable interrupts (interrupts can happen during NOPs)
cli(); rt_data.current_fb = (volatile int)current_fb; sei();
asm("nop"); asm("nop"); asm("nop"); asm("nop");
// fetch variable with interrupts off, then re-enable interrupts (interrupts can happen during NOPs)
cli(); rt_data.raw_hs_temp = (volatile unsigned)raw_hs_temp; sei();
asm("nop"); asm("nop"); asm("nop"); asm("nop");
// fetch variable with interrupts off, then re-enable interrupts (interrupts can happen during NOPs)
cli(); rt_data.raw_throttle = (volatile unsigned)raw_throttle; sei();
asm("nop"); asm("nop"); asm("nop"); asm("nop");
}
void read_config(void)
{
eeprom_read_block(&config, (void *)EE_CONFIG_ADDRESS, sizeof(config));
if (config.magic == 0x12ab) {
// magic OK
if (calc_block_crc(sizeof(config) - sizeof(unsigned), (unsigned char *)&config) ==
config.crc) {
// CRC ok
return;
}
}
memcpy_P(&config, &default_config, sizeof(config));
}
void write_config(void)
{
config.crc = calc_block_crc(sizeof(config) - sizeof(unsigned), (unsigned char *)&config);
eeprom_write_block(&config, (void *)EE_CONFIG_ADDRESS, sizeof(config));
}
void show_menu(char *str)
{
sprintf_P(str, PSTR("Cougar OS controller firmware v%d.%d\r\n"),
MAJOR_VERSION, MINOR_VERSION);
uart_putstr(str);
}
void show_config(char *str)
{
sprintf_P(str, PSTR("Kp=%d Ki=%d\r\n"), config.Kp, config.Ki);
uart_putstr(str);
sprintf_P(str, PSTR("throttle_min_raw_counts=%u throttle_max_raw_counts=%u\r\n"),
config.throttle_min_raw_counts, config.throttle_max_raw_counts);
uart_putstr(str);
sprintf_P(str, PSTR("throttle_pos_gain=%u throttle_pwm_gain=%u\r\n"),
config.throttle_pos_gain, config.throttle_pos_gain);
uart_putstr(str);
sprintf_P(str, PSTR("current_ramp_rate=%d\r\n"), config.current_ramp_rate);
uart_putstr(str);
}
int main(void)
{
int x;
unsigned tm_show_data;
unsigned char cmdpos, cmdok;
char cmd[32];
char str[80];
#ifdef crc_address
unsigned crc1, crc2;
crc1 = pgm_read_word(crc_address); // read program CRC
crc2 = calc_prog_crc(crc_address); // read program CRC
if (crc1 != crc2) {
// program CRC error
while(1); // do nothing for ever
}
#endif
wdt_enable(WDTO_250MS); // enable watchdog
PORTD = 0xff & ~PD_LED & ~PD_CONTACTOR; // PORTD weak pullups, LED output pins low (LEDs off)
DDRD = PD_LED & PD_CONTACTOR; // two pins outputs
PORTC = ~PC_ANALOGS_USED; // weaks pull ups on _except_ for analog input pins
PORTB = 0xff & ~PB_PWM; // PWM output low, other outputs high, weak pullups on
DDRB = PB_PWM | PB_OC_CLEAR; // two pins outputs
// External Vcc (5v) for analog reference
ADMUX = (1 << REFS0);
// enable ADC, prescale = 128, so conversion clock is 16M / 128 = 125KHz
// a conversion take 13 cycles, at 125KHz equals 104uS
// the fastest we can convert is 9.6 KHz
// if we convert every other PWM cycle, that is 8KHz
// see page 198 of ATMEG8 manual
ADCSRA = (1 << ADEN) | (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0);
// do a conversion on channel 2 - the first conversion takes 25 cycles - so do it now
ADMUX = ADMUX = (1 << REFS0) | 2;
ADCSRA = (1 << ADEN) | (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0) | (1 << ADSC);
while (ADCSRA & (1 << ADSC));
// set up input capture 1 interrupt at 976Hz
// this is only for temporary timing until timer 1 is used for PWM
// the reason for 976Hz instead of 1000Hz is explained below
TCNT1 = 0; // load 16 bit counter 1
ICR1 = (long)F_OSC / 976; // timer at 976 Hz
TCCR1A = 0; // no output action on match
// let counter 1 run at fosc, reset to 0 at ICR1
TCCR1B = (1 << WGM13) | (1 << WGM12) | (1 << CS10);
TIMSK = (1 << TICIE1); // enable input capture 1 interrupt
read_config(); // read config from EEprom
config_pi(); // configure PI loop from config structure
// interrups are now enabled by config_pi() - sei() instruction in config_pi()
idle_loopcount = wait_time(100); // wait 100mS and remember how many loops we did
wdt_reset(); // kick watchdog
// now that voltages have settled, measure Vref
if (!measure_vref()) {
// vref out of range
while(1) {
wdt_reset(); // kick watchdog
}
}
// clear overcurrent fault (powerup in unknown state)
clear_oc();
// now configure timer 1 for PWM
TIMSK = 0; // no timer 1 interrupt
TCCR1B = 0; // stop counter 1
TCNT1 = 0; // load 16 bit counter 1
OCR1A = 0; // set initial PWM duty value to 0
TCCR1A = (1 << COM1A1) | (1 << WGM11); // Pase Correct PWM mode, 9 bit
TCCR1B = (1 << CS10); // Pre-scaler = 1
OCR1A = 0; // again, just to be safe
TIMSK = (1 << TOIE1); // enable overflow 1 interrupt
// now the PWM frequency = 16000000 / (1 << 9) / 2
// so PWM frequency = 16000000 / 1024 = 15625Hz
// now, counter_1k is incremented every 16 interrupt, so 15625 / 16 = 976.5625Hz
// this is why we run SIG_INPUT_CAPTURE1 at 976Hz
setup_uart(19200, PARITY_NONE, BITS_8_1); // uart 19200,n,8,1
show_menu(str); // might as well
// init some time variables
tm_show_data = get_time();
// now listen on serial port for commands
memset(cmd, 0, sizeof(cmd)); cmdpos = 0;
while (1) {
wdt_reset();
x = uart_getch();
if (x >= 0) {
if (x != 0x0d) {
// not a CR
uart_putch(x); // echo the character back
if (cmdpos < (sizeof(cmd) - 1)) {
cmd[cmdpos++] = x; // add character to command string
cmd[cmdpos] = 0; // and terminate command string
}
}
else {
// got a CR
uart_putch(0x0a); uart_putch(0x0d); // echo back LF and CR
cmdok = 0;
if (cmdpos > 0) {
for (x = 0; x < (int)(cmdpos - 1); x++) {
if (cmd[x] == ' ') {
// have a space character, terminate at this position
// and get numeric value
cmd[x] = 0; x = atoi(&cmd[x + 1]); cmdok = 1;
}
}
}
if (cmdok) {
// cmd is string, x is numeric value
if (!strcmp_P(cmd, PSTR("save"))) {
write_config();
sprintf_P(str, PSTR("configuration written to EE\r\n"));
uart_putstr(str);
}
else if (!strcmp_P(cmd, PSTR("idle"))) {
sprintf_P(str, PSTR("AVR %lu%% idle\r\n"),
wait_time(100) * (long)100 / idle_loopcount);
uart_putstr(str);
}
else if (!strcmp_P(cmd, PSTR("kp"))) {
if ((unsigned)x <= 500) {
config.Kp = x; config_pi();
show_config(str);
}
}
else if (!strcmp_P(cmd, PSTR("ki"))) {
if ((unsigned)x <= 500) {
config.Ki = x; config_pi();
show_config(str);
}
}
else if (!strcmp_P(cmd, PSTR("t-min-rc"))) {
if ((unsigned)x <= 1023) {
cli(); config.throttle_min_raw_counts = x; sei();
show_config(str);
}
}
else if (!strcmp_P(cmd, PSTR("t-max-rc"))) {
if ((unsigned)x <= 1023) {
cli(); config.throttle_max_raw_counts = x; sei();
show_config(str);
}
}
else if (!strcmp_P(cmd, PSTR("t-pos-gain"))) {
if ((unsigned)x <= 128) {
cli(); config.throttle_pos_gain = x; sei();
show_config(str);
}
}
else if (!strcmp_P(cmd, PSTR("t-pwm-gain"))) {
if ((unsigned)x <= 128) {
cli(); config.throttle_pwm_gain = x; sei();
show_config(str);
}
}
else if (!strcmp_P(cmd, PSTR("c-rr"))) {
if ((unsigned)x <= 100) {
cli(); config.current_ramp_rate = x; sei();
show_config(str);
}
}
}
else show_menu(str);
// reset command string
cmdpos = 0; cmd[0] = 0;
}
}
/* add non time-critical code below */
fetch_rt_data();
if (diff_time(tm_show_data) >= 200) {
// 200mS passed since last time, adjust tm_show_data to trigger in 200mS again
tm_show_data += 200;
sprintf_P(str, PSTR("TR=%03d CR=%03d CF=%03d HS=%04u RT=%04u\r\n"),
rt_data.throttle_ref, rt_data.current_ref, rt_data.current_fb,
rt_data.raw_hs_temp, rt_data.raw_throttle);
uart_putstr(str);
}
}
return(0);
}
Cougar.h
#define MAJOR_VERSION 0 #define MINOR_VERSION 1 #define F_OSC 16000000 // oscillator-frequency in Hz #define PROGSTART 0x0000 // program start address #define EE_CONFIG_ADDRESS 0 // address of config in EEprom #define OC_CLEAR_ENABLED // defin to enable AVR to clear OC fault #define NUM_OC_CYCLES_OFF 4 // number of overcurrent cycles off (at 4KHz) #define MAX_CURRENT_REF 511 // max current ref into PI loop #define PINB_OC_STATE (1 << PINB0) // OC state (high means fault) #define PB_PWM (1 << PB1) // PWM output pin (high to turn FETs on) #define PB_OC_CLEAR (1 << PB2) // OC clear (low to clear, high for normal operation) #define PD_LED (1 << PD6) // IDLE LED - high to light LED #define PD_CONTACTOR (1 << PD7) // Contactor Opto LED - high to light LED // three analog inputs used, these pins must be inputs and weak pullups off #define PC_ANALOGS_USED ((1 << PC0) | (1 << PC1) | (1 << PC2)) #define PARITY_NONE 0x00 #define PARITY_EVEN 0x02 #define PARITY_ODD 0x03 #define BITS_7_1 0x02 #define BITS_7_2 0x06 #define BITS_8_1 0x03 #define BITS_8_2 0x07 #define UART_RXBUF_SIZE 16 #define UART_TXBUF_SIZE 128 // function prototypes // get character from uart fifo, return -1 if fifo empty int uart_getch(void); // put character to uart (return 1 if fifo full, else 0) unsigned char uart_putch(char c); // put string to uart void uart_putstr(char *str); // set up UART to specified baud, parity, and bits void setup_uart(unsigned long baud, unsigned char parity, unsigned char bits);
Serial.c
/*
serial port support for cougar.c
*/
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/iom8.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "cougar.h"
// UART (serial)
typedef struct {
unsigned char rxbuf[UART_RXBUF_SIZE];
unsigned char txbuf[UART_TXBUF_SIZE];
unsigned rxhead;
unsigned rxtail;
unsigned txhead;
unsigned txtail;
} uart_fifo_type;
uart_fifo_type uart;
/* uart receive interrupt */
SIGNAL(SIG_UART_RECV)
{
unsigned char c;
unsigned i;
c = UDR;
i = uart.rxhead + 1;
if (i >= UART_RXBUF_SIZE) i = 0;
if (i != uart.rxtail) {
// fifo not full
uart.rxbuf[uart.rxhead] = c;
uart.rxhead = i;
}
}
/* uart UDR empty interrupt */
SIGNAL(SIG_UART_DATA)
{
unsigned i;
i = uart.txtail;
if (i != uart.txhead) {
UDR = uart.txbuf[i++];
if (i >= UART_TXBUF_SIZE) i = 0;
uart.txtail = i;
}
else {
// disable TX buffer empty interrupt
UCSRB = (1 << RXEN) | (1 << TXEN) | (1 << RXCIE);
}
}
// get character from uart fifo, return -1 if fifo empty
int uart_getch(void)
{
unsigned char c;
unsigned i, j;
i = uart.rxtail;
cli(); j = uart.rxhead; sei();
if (i != j) {
c = uart.rxbuf[i++];
if (i >= UART_RXBUF_SIZE) i = 0;
cli(); uart.rxtail = i; sei();
return(c);
}
return(-1);
}
// put character to uart (return 1 if fifo full, else 0)
unsigned char uart_putch(char c)
{
unsigned i, j;
i = uart.txhead + 1;
if (i >= UART_TXBUF_SIZE) i = 0;
cli(); j = uart.txtail; sei();
if (i == j) {
// fifo full
return(1);
}
uart.txbuf[uart.txhead] = c;
cli(); uart.txhead = i; sei();
// enable TX buffer empty interrupt
UCSRB = (1 << RXEN) | (1 << TXEN) | (1 << RXCIE) | (1 << UDRIE);
return(0);
}
// put string to uart
void uart_putstr(char *str)
{
char ch;
while (1) {
ch = *str++;
if (ch == 0) break;
while (uart_putch(ch));
}
}
// set up UART to specified baud, parity, and bits
void setup_uart(unsigned long baud, unsigned char parity, unsigned char bits)
{
unsigned int ubrr;
ubrr = (F_OSC / ((unsigned long)16 * baud)) - 1;
UBRRL = ubrr & 0xff;
UBRRH = ubrr >> 8;
UCSRC = (parity << 4) | (bits << 1) | (1 << URSEL);
UCSRB = (1 << RXEN) | (1 << TXEN) | (1 << RXCIE);
}
--Adamj12b 19:30, 5 October 2009 (EDT)
Serial Command List
Serial Hardware is NOT RS232, it is FTDI 5v logic serial. Beware!
Commands:
Format -
<Command><" "><INTEGER>
<SAVE>
Example:
pctime 50
save
saves a new precharge time of 5 seconds
save - Save setting
idle - ? Idle controller
restart - restart controller
reset-ah - reset Amp hours
pc-time - Precharge contactor/relay time
kp - PI loop proportional gain
ki - PI loop integreal gain
t-min-rc - config.throttle_min_raw_counts - throttle low voltage (pedal to metal)
t-max-rc - config.throttle_max_raw_counts - throttle high voltage (foot off pedal)
t-pos-gain - config.throttle_pos_gain - gain for actual throttle position
t-pwm-gain - config.throttle_pwm_gain - gain for pwm (voltage)
c-rr - config.current_ramp_rate - current ramp rate
rtd-period - Period between output of controller data to the serial port
pwm-filter - ?
motor-os-dt - Motor Overspeed detect time
pwm-deadzone - ?
motor-sc-amps
DATA:
If you set rtd-period # to a value in ms, this will be how often the controller spits out the data string with the real time parameters.
The break down is as follows:
TR = Controllers calculated throttle position. 0-511
CR = Controllers current reference based on throttle and other factors. 0-511
CF = Current feedback from LEM current sensor 0-511
PW = PWM duty cycle of controller 0-511
HS = Heat-sink Temp in raw ADC counts 0-1023
RT = Raw Throttle counts from the ADC 0-1023
FB = Fault Bits. Hex output with each fault and status code. Normal 00
BA = Calculated Battery amps 0-511
AH = Calculated Amp Hours consumed 0-999.9
Here is an example string:
TR=000 CR=000 CF=002 PW=000 HS=0315 RT=0716 FB=00 BA=000 AH=000.0
This shows:
TR=000 No throttle
CR=000 Controller is not commanding any current
CF=002 Current sensor reading of 002, it will fluctuate a few counts in increments of 002
PW=000 No pwm output
HS=0315 heatsink temp of 315 is about 76 ish F.
RT=0716 The throttle all the way up value
FB=00 No fault codes. this will change on HPL, pre-charge, overspeed, overtemp, and no throttle or current sensor
BA=000 no battery current
AH=000.0 no AH consumed because you havnt used any power yet. lol
Link to Adam Brunettes [1] page with his software - RTD explorer that graphs this all automatically for you.
