C-Code für Fahrtregler anpassen

[Andre Meschke (Gast)]

Hallo,
ich habe hier einen Code für einen RC Fahrtregler auf Atmega8 Basis.
Der Regler funktioniert auch gut bis auf eine Kleinigkeit die jedoch 
sehr stört.
Und zwar egal ob vorwärts oder rückwärts nach ca 75% des 
Knüppelausschlages an der Fernbedienung wenn der Motor auch mit 75% 
seiner Leistung dreht kommt es zu einem Sprung auf 100%. Mir fehlt also 
proportionaler Stellweg.
An welcher Stelle muss ich den Code abändern damit das passt?

/* Brushed project
Main code file. 
 */

//Set your controller here
#include "../pindefs/tz85a.h"


#include <avr/io.h>
#include <avr/pgmspace.h>
#include <stdint.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <math.h>
#include <avr/eeprom.h>

//Define RC States
#define unitialised  0
#define forward  1
#define backward  2
#define brake  3

//Define Temp States
#define HOT  2
#define WARM 1
#define COOL 0

volatile uint8_t state = 0;
volatile uint16_t prevTime = 0;
volatile uint16_t rcTime = 0;
volatile uint8_t time0 = 0;
volatile uint8_t failsafe = 0;
volatile uint8_t timeout = 50;
volatile uint8_t newState = 0;
volatile uint8_t lets_get_high = 0;
volatile uint8_t tempState = 0;
volatile uint8_t rcTick = 0;
volatile uint8_t desiredPWM = 0;

//Stored data variables
volatile uint16_t rcLow = RC_LOW;
volatile uint16_t rcHigh = RC_HIGH;
volatile uint16_t rcMid = (RC_LOW + RC_HIGH) / 2;
volatile uint8_t maxSlew = MAX_SLEW;
volatile uint8_t tempLimit = TEMP_LIMIT;
volatile uint8_t goExpo = EXPO;

//Define memory states
uint16_t EEMEM storedRcLow = RC_LOW;
uint16_t EEMEM storedRcHigh = RC_HIGH;
uint8_t EEMEM storedSlewRate = MAX_SLEW;
uint8_t EEMEM storedExpo = EXPO;
uint8_t EEMEM storedTempLimit = TEMP_LIMIT;

//Setup 2 ports which we are using for H bridge. e.g.
/* Forward = B High, A Low

   Reverse = B Low,  A High
 */

#define FORWARD_LOW  LOW_A
#define FORWARD_LOW_PORT   LOW_A_PORT

#define FORWARD_HIGH HIGH_B
#define FORWARD_HIGH_PORT  HIGH_B_PORT

#define BACKWARD_LOW  LOW_B
#define BACKWARD_LOW_PORT  LOW_B_PORT

#define BACKWARD_HIGH HIGH_A
#define BACKWARD_HIGH_PORT HIGH_A_PORT

inline void setForwardLow();
inline void clrForwardLow();
inline void setForwardHigh();
inline void clrForwardHigh();

inline void setBackwardLow();
inline void clrBackwardLow();
inline void setBackwardHigh();
inline void clrBackwardHigh();

//Motor State Functions
void goForwards();
void braking();
void goBackwards();

//Programming functions
void motorBeep(uint8_t length);
void fastBeep(uint8_t length);
void waitForState(uint8_t waitForState);
void readData();
void calibrateRC();
void setSlewRate();
void setExpo();
void setTempLimit();

int main() {
    //Initialisation

    //Setup Outputs
    _delay_ms(10);

    clrBackwardLow();
    clrBackwardHigh();
    clrForwardLow();
    clrForwardHigh();

    SET_HIGH_A_PORT |= (1 << HIGH_A);
    SET_HIGH_B_PORT |= (1 << HIGH_B);
    SET_HIGH_C_PORT |= (1 << HIGH_C);

    SET_LOW_A_PORT |= (1 << LOW_A);
    SET_LOW_B_PORT |= (1 << LOW_B);
    SET_LOW_C_PORT |= (1 << LOW_C);

    //setForwardLow();
    

    //_delay_ms(100);

    //Setup Timer
    TCCR0 = 0b00000011; //Setup Timer 0 - scaling or (go check the datasheet and fill it in)
    TIMSK = (1 << TOIE0) | (1 << OCIE2) | (1 << TOIE2); //Enable Timer0 Overflow interrupt, Timer2 Output Compare and Timer2 Overflow interrupt

    //Setup PWM Timer
    OCR2 = 0x00; //Set the compare value to 0 or off
    TCCR2 = (1 << CS21); //Set the timer 2 scaling of (go check the datasheet and fill it in)

    //Enable RC Interrupt
    MCUCR |= (1 << ISC00); //Set INT0 to trigger on both edges
    GICR |= (1 << INT0); //Enable INT0

    newState = unitialised;
    braking();

    _delay_ms(100);



    //Setup ADC
#ifdef TEMP_ADMUX
  if (tempLimit){
      ADCSRA |= (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0); // Set ADC prescaler to 128 - 125KHz sample rate @ 16MHz

      ADMUX |= (1 << REFS0); // Set ADC reference to AVCC
      ADMUX |= (1 << ADLAR); // Left adjust ADC result to allow easy 8 bit reading

      ADMUX |= TEMP_ADMUX; //Set ADC to temp sensor

      ADCSRA |= (1 << ADFR); // Set ADC to Free-Running Mode
      ADCSRA |= (1 << ADEN); // Enable ADC
      ADCSRA |= (1 << ADIE); // Enable ADC Interrupt
      ADCSRA |= (1 << ADSC); // Start A2D Conversions
  }
#endif

    //while(1){
    //setForwardHigh();
    //_delay_ms(1);
    //clrForwardHigh();
    //}

    sei();
    //End initialisation 

    //Calibration loop
    uint8_t timeout = 0;
    uint8_t calibrating = CALIBRATION;
    while (calibrating) {
        //If we are getting RC pusles
        if (failsafe > 10) {
            //if we are getting a pulse see if its up the top.
            if (newState == forward && desiredPWM > 100) {
                //Wait for 2s and see if it stays high
                timeout = 0;
                while (newState == forward && desiredPWM > 100 && timeout < 199) {
                    _delay_ms(20);
                    timeout++;
                }

                //Check if its stayed high 
                if (timeout > 190) {

                    //Yay we are in programming mode
                    calibrateRC();
                    _delay_ms(2000);
                    setSlewRate();
                    _delay_ms(2000);
                    setExpo();
                    _delay_ms(2000);
                    setTempLimit();
                    _delay_ms(2000);
                    while (newState != brake) {
                        fastBeep(4);
                    }
                }
                calibrating = 0;
            } else {
                calibrating = 0;
            }
        }

        //If not wait and beep for 20s
        _delay_ms(500);
        timeout++;
        if (timeout > 19) {
            calibrating = 0;
        }
        if (timeout % 2) {
            motorBeep(1);
        }
    }

    //readData();

    timeout = 0;
    //waitForState(brake);

    motorBeep(3);
    

    //Main loop
    //Here we manage what mode we are in everything else is done in interrupts
    while (1) {
        //RC Tick runs @ approximately 1kHz on @ 16Mhz or 500hz @ 8Mhz        
        if (rcTick) {
            //Manage State
             
            
            if (state != newState) {
            
                //If we are in the brake state then we can go in either direction
                //if (state == brake){

                if (newState == forward && state == brake) {
                    OCR2 = 0;
                    goForwards();
                } else if (newState == backward && state == brake) {
                    OCR2 = 0;
                    goBackwards();
                } else {
                    //If we have ramped down then go to braking mode
                    if (OCR2 <= 10) {
                        braking();
                        OCR2 = 255;
                    }                        //Other wise we want to change our state so first we need to ramp down, then we can change state.
                    else {
                        OCR2 = OCR2 - maxSlew;
                    }
                }
            }                //Manage slew rate
            else if (OCR2 != desiredPWM) {
                if (desiredPWM > (OCR2 + maxSlew)) {
                    OCR2 = OCR2 + maxSlew;
                } else if (desiredPWM < (OCR2 - maxSlew)) {
                    OCR2 = OCR2 - maxSlew;
                } else {
                    OCR2 = desiredPWM;
                } 
            }
            rcTick = 0; 
        }
    }
}


//This interrupt manages failsafe and time0 for upper half of RC timer (lower half is TCNT0)

ISR(TIMER0_OVF_vect) {
    //Check failsafe

    if (timeout == 0) { //If we are out of counts go to braking mode
        newState = brake;
    } else {
        timeout--; //otherwise decrease failsafe counter
    }
    time0++; //time0 is upper bit for RC timer. 
    rcTick++;
}

//This interrupt manages RC pulses

ISR(INT0_vect) {
    //Read in the current time
    uint16_t time = TCNT0; //Read lower
    time = time + time0 * 256; //Add upper
    //Read in current time
    if (RC_PORT & (1 << RC_PIN)) { //If the pin is high (then its just switched on)
        prevTime = time; //then save the current time
    } else {
        uint16_t time_diff = time - prevTime;
        rcTime = time_diff;
        //Update PWM and direction
        uint8_t deadzone = DEADTIME;
        uint8_t buffer = BUFFERTIME;
        uint8_t maxOut = MAXOUTTIME;

 

        if (((time_diff > (rcLow - buffer)) && (time_diff < (rcHigh + buffer))) && (tempState != HOT)) { //Check for valid pulse
            if (failsafe > 10) { //Need 10 good pulses before we start
                failsafe = 15; //Set valid pulse counter (15-10 = 5) therfore we can receive 5 bad pulses before we stop
                timeout = 50; //Set timeout counter

                //Vaild signal
       
                if (time_diff > (rcMid - deadzone) && time_diff < (rcMid + deadzone)) { //If center brake
                    desiredPWM = 255;
                    newState = brake;

                } else if (time_diff < rcMid) { //If low then go backwards

                    if (time_diff < (rcLow + maxOut)) {
                        desiredPWM = 255;
                    } else {
                        desiredPWM = (rcMid - deadzone - time_diff)*256 / (rcMid - deadzone - rcLow);
                        if (EXPO) {
                            desiredPWM = (uint16_t) desiredPWM * desiredPWM / 256;
                        }
                    }
                    newState = backward;

          if(tempLimit){
                      if (tempState == WARM && OCR2 > 128) {
                          desiredPWM = 128;
                      }
          }

                } else { //Else go forward
                    if (time_diff > (rcHigh - maxOut)) {
                        desiredPWM = 255;
                    } else {
                        desiredPWM = (time_diff - rcMid - deadzone)*256 / (rcHigh - rcMid - deadzone);
                        if (EXPO) {
                            desiredPWM = (uint16_t) desiredPWM * desiredPWM / 256;
                        }
                    }
                    newState = forward;

          if(tempLimit){
                    if (tempState == WARM && OCR2 > 128) {
                        desiredPWM = 128;
                    }
          }

                }
            } else {
                failsafe++; //If havent got 10 valid pulses yet increase count and keep waiting
            }
        } else { //If there is an invalid pulse
            //Failsafe
            failsafe--; //decrease counter
            if (failsafe < 10) { //If we have had enough invalid pulses
                newState = brake; //go to failsafe breaking mode
            }
        }
    }
}

ISR(TIMER2_COMP_vect) { //When comparator is triggered clear low ports (off part of PWM cycle)
    if (OCR2 < 255) {
        if (state != brake) {
            //Clear high
            clrForwardHigh();
            clrBackwardHigh();
        }
    }
}

ISR(TIMER2_OVF_vect) { //When timer overflows enable low port for current state
    if (OCR2 > 0) {
        if (state == forward) {
            setForwardHigh();
        } else if (state == backward) {
            setBackwardHigh();
        }
    }
    if (OCR2 > 250 && state != brake) {
        lets_get_high++; //Gotta keep the charge pump circuit charged
        if (lets_get_high > 50) { //If it hasn't had a chance to charge in a while
            clrForwardHigh(); //Clear it then reset counter   
            clrBackwardHigh(); //Now pumped up and remaining high so we don't nasty shoot through which ends in magic smoke :)
            lets_get_high = 0;
        }
    }
}

#ifdef TEMP_ADMUX
ISR(ADC_vect) {
    if (ADCH < I_AM_HOT) {
        tempState = HOT;
        newState = brake;
    } else if (ADCH < I_AM_WARM) {
        tempState = WARM;
    } else {
        tempState = COOL;
    }
}
#endif

inline void setForwardLow() {
    if (LOW_ACTIVE_LOW) {
        FORWARD_LOW_PORT &= ~(1 << FORWARD_LOW);
    } else {
        FORWARD_LOW_PORT |= (1 << FORWARD_LOW);
    }
}

inline void clrForwardLow() {
    if (LOW_ACTIVE_LOW) {
        FORWARD_LOW_PORT |= (1 << FORWARD_LOW);
    } else {
        FORWARD_LOW_PORT &= ~(1 << FORWARD_LOW);
    }
}

inline void setForwardHigh() {
    if (HIGH_ACTIVE_LOW) {
        FORWARD_HIGH_PORT &= ~(1 << FORWARD_HIGH);
    } else {
        FORWARD_HIGH_PORT |= (1 << FORWARD_HIGH);
    }
}

inline void clrForwardHigh() {
    if (HIGH_ACTIVE_LOW) {
        FORWARD_HIGH_PORT |= (1 << FORWARD_HIGH);
    } else {
        FORWARD_HIGH_PORT &= ~(1 << FORWARD_HIGH);
    }
}

inline void setBackwardLow() {
    if (LOW_ACTIVE_LOW) {
        BACKWARD_LOW_PORT &= ~(1 << BACKWARD_LOW);
    } else {
        BACKWARD_LOW_PORT |= (1 << BACKWARD_LOW);
    }
}

inline void clrBackwardLow() {
    if (LOW_ACTIVE_LOW) {
        BACKWARD_LOW_PORT |= (1 << BACKWARD_LOW);
    } else {
        BACKWARD_LOW_PORT &= ~(1 << BACKWARD_LOW);
    }
}

inline void setBackwardHigh() {
    if (HIGH_ACTIVE_LOW) {
        BACKWARD_HIGH_PORT &= ~(1 << BACKWARD_HIGH);
    } else {
        BACKWARD_HIGH_PORT |= (1 << BACKWARD_HIGH);
    }
}

inline void clrBackwardHigh() {
    if (HIGH_ACTIVE_LOW) {
        BACKWARD_HIGH_PORT |= (1 << BACKWARD_HIGH);
    } else {
        BACKWARD_HIGH_PORT &= ~(1 << BACKWARD_HIGH);
    }
}

//Motor State Functions

void goForwards() {
    if (state != forward) {
        cli();

        //Clear unused pins
        clrBackwardHigh();
        clrBackwardLow();
        _delay_us(200); //Fet switch delay
        setForwardLow();
        _delay_us(200); //Fet switch delay
        setForwardHigh();
        state = forward; //Up
        sei();
    }
}

void braking() {

    if (state != brake) {
        cli();

        //Clear unused pins
        clrForwardHigh();
        clrBackwardHigh();
        _delay_us(200); //Fet switch delay
        setForwardLow();
        setBackwardLow();
        state = brake;
        _delay_ms(10);
        sei();
    }
}

void goBackwards() {
    if (state != backward) {
        cli();

        //Clear high
        clrForwardHigh();
        clrForwardLow();
        _delay_us(200); //Fet switch delay
        setBackwardLow();
        _delay_us(200); //Fet switch delay
        setBackwardHigh();
        state = backward;
        sei();
    }
}

void motorBeep(uint8_t length) {
    OCR2 = 10;
    uint8_t count = 0;
    while (count < length) {
        if (count % 2) {
            goForwards();
        } else {
            goBackwards();
        }
        _delay_ms(200);
        count++;
        braking();
        _delay_ms(300);
    }
    braking();
    OCR2 = 0;
}

void fastBeep(uint8_t length) {
    OCR2 = 20;
    uint8_t count = 0;
    while (count < length) {
        if (count % 2) {
            goForwards();
        } else {
            goBackwards();
        }
        _delay_ms(50);
        count++;
        braking();
        _delay_ms(100);
    }
    braking();
    OCR2 = 0;
}

void waitForState(uint8_t waitForState) {
    while (newState != waitForState || failsafe < 13) {
        _delay_ms(100);
    }
}

void readData() {
    //if we have valid EEPROM data read it in
    if (eeprom_read_word(&storedRcLow) != 0xFFFF) {
        rcLow = eeprom_read_word(&storedRcLow);
        rcHigh = eeprom_read_word(&storedRcHigh);
        rcMid = (rcLow + rcHigh) / 2;
    }
    if (eeprom_read_byte(&storedSlewRate) != 0xFF) {
        maxSlew = eeprom_read_byte(&storedSlewRate);
    }
    if (eeprom_read_byte(&storedTempLimit) != 0xFF) {
        tempLimit = eeprom_read_byte(&storedTempLimit);
    }
    if (eeprom_read_byte(&storedExpo) != 0xFF) {
        goExpo = eeprom_read_byte(&storedExpo);
    }
}

void calibrateRC() {
    uint16_t min = 10000;
    uint16_t max = 1;
    fastBeep(6);
    _delay_ms(700);

    //Move stick all the way down                     
    waitForState(backward);
    motorBeep(1);
    while (newState == backward || newState == brake) {
        if (min > rcTime && min > RC_LOW / 2) {
            min = rcTime;
        }
        if (max < rcTime && max < RC_HIGH * 3 / 2) {
            max = rcTime;
        }
    }
    motorBeep(2);
    waitForState(forward);
    while (newState == forward || newState == brake) {
        if (min > rcTime && rcTime > RC_LOW * 2 / 3) {
            min = rcTime;
        }
        if (max < rcTime && rcTime < RC_HIGH * 3 / 2) {
            max = rcTime;
        }
    }
    motorBeep(3);
    eeprom_write_word(&storedRcLow, min);
    eeprom_write_word(&storedRcHigh, max);
}

void setSlewRate() {
    fastBeep(6);
    //Wait for stick to center
    waitForState(brake);
    _delay_ms(1000);
    motorBeep(1);

    while (newState == brake) {
        _delay_ms(1000);
    }
    uint8_t loop = 1;
    uint8_t slew = 2;
    while (loop) {
        if (newState == forward) {
            if (slew < 10) {
                slew++;
            }
            motorBeep(slew);
            _delay_ms(1000);
        }

        if (newState == backward) {
            if (slew > 1) {
                slew--;
            }
            motorBeep(slew);
            _delay_ms(1000);
        }

        if (newState == brake) {
            _delay_ms(1000);
            if (newState == brake) {
                _delay_ms(1000);
                if (newState == brake) {
                    motorBeep(slew);
                    if (F_CPU == 8000000){
                        slew = slew * 2;
                    }
                    eeprom_write_byte(&storedSlewRate, slew);
                    loop = 0;
                }
            }
        }
    }
}

void setExpo() {
    fastBeep(6);
    //Wait for stick to center
    waitForState(brake);
    _delay_ms(1000);
    motorBeep(1);

    while (newState == brake) {
        _delay_ms(1000);
    }

    if (newState == forward) {
        eeprom_write_byte(&storedExpo, 1);
        motorBeep(3);
        _delay_ms(1000);
    }

    if (newState == backward) {
        eeprom_write_byte(&storedExpo, 0);
        motorBeep(4);
        _delay_ms(1000);
    }
}

void setTempLimit() {
    fastBeep(6);
    //Wait for stick to center
    waitForState(brake);
    _delay_ms(1000);
    motorBeep(1);

    while (newState == brake) {
        _delay_ms(1000);
    }

    if (newState == forward) {
        eeprom_write_byte(&storedTempLimit, 1);
        motorBeep(3);
        _delay_ms(1000);
    }

    if (newState == backward) {
        eeprom_write_byte(&storedTempLimit, 0);
        motorBeep(4);
        _delay_ms(1000);
    }
}

[Karl H. (kbuchegg)]

Ich hätte mal gesagt, dass für Vorwärts fahren, die gesuchte Stelle hier 
zu finden ist

                    if (time_diff > (rcHigh - maxOut)) {
                        desiredPWM = 255;
                    } else {
                        desiredPWM = (time_diff - rcMid - deadzone)*256 / (rcHigh - rcMid - deadzone);

Die Zuweisung von 255 dürfte für Vollgas verantwortlich sein.
D.h. der Wert von time_diff ist grösser als rcHigh bzw. rcHigh - maxOut. 
Enteder ist rcHigh zu klein gesetzt oder maxOut zu gross.

rcHigh kommt von hier

volatile uint16_t rcLow = RC_LOW;
volatile uint16_t rcHigh = RC_HIGH;

und die Makrodefinition kann ich nicht sehen. Steckt wahrscheinlich im 
Header File

#include "../pindefs/tz85a.h"

oder wird per Makefile Option vorgegeben. Aber irgendwo muss er sein.
Selbiges für

        uint8_t maxOut = MAXOUTTIME;

Du kannst ja mal probieren, ob wir überhaupt an der richtigen Stelle 
sind.
Wenn du die 255 änderst zu

                    if (time_diff > (rcHigh - maxOut)) {
                        desiredPWM = 128;

dann sollte der Motor eigentlich bei überschreiten deiner ominösen 75% 
anstatt auf Vollgas einfach auf 0 gehen, wenn ich die Funktion der PWM 
auf die Schnelle richtig erkannt habe.

[Karl H. (kbuchegg)]

Halt. Kommando retour.
Die High und Low Werte kommen aus dem EEPROM und werden kalibriert. D.h. 
wenn der MAXOUTTIME nicht aberwitzig hoch ist, dann ist deine 
Kalibrierung des Reglers an deine Fernsteueranlage einfach nur mies oder 
gar nicht durchgeführt worden.

[Andre Meschke (Gast)]

Hallo,
auf Null zu gehen wäre auch nicht ganz richtig,

[Andre Meschke (Gast)]

Die Kalibrierung hab ich gemacht.

[Karl H. (kbuchegg)]

Andre Meschke schrieb:
> Hallo,
> auf Null zu gehen wäre auch nicht ganz richtig,


das weiss ich schon.

Aber ehe ich da jetzt grossartig weiter analysiere, will ich erst mal 
wissen, ob die auf dem schnellen Weg identifizierte Programmposition 
überhaupt die richtige Stelle ist. Und dazu schlage ich eine 
Modifikation vor, dessen Auswirkung sofort und ohne Messgerät leicht zu 
sehen und zu überprüfen ist. Was einfacheres als "anstelle von 100% geht 
der Motor in den Stillstand (oder Halbgas?)" kann ich mir kaum 
vorstellen. Passiert das tatsächlich, dann weiss ich, dass das hier die 
richtige Codestelle ist und spar mir die Analyse der restlichen 48 
Seiten Code. Und dann sehen wir weiter, wie es zu diesem Problem kommen 
kann.



PS: Sorry. Ich hab irrtümlich auf 'Bearbeiten' geklickt anstatt auf 
'Antworten'.
Kannst du das Header File noch mal posten`?

[Andre Meschke (Gast)]

/* -----------------------------

ESC Name:         F20A
Current Rating:   20A
Added by:         Steven Martin
Date:             4/04/2011
Tested by:        
Date:             

Comments:
Has same pinout as TZ85a         
Still would not classify as battle tested.

------------------------------- */
//Need to setup the high and low sides
//Must set direction port, port and pin. 

//Channel A
#define SET_HIGH_A_PORT DDRD
#define HIGH_A_PORT PORTD
#define HIGH_A 4

#define SET_LOW_A_PORT DDRD
#define LOW_A_PORT PORTD
#define LOW_A  5

//Channel B
#define SET_HIGH_B_PORT DDRC
#define HIGH_B_PORT PORTC
#define HIGH_B  5

#define SET_LOW_B_PORT DDRC
#define LOW_B_PORT PORTC
#define LOW_B  4

//Channel C
#define SET_HIGH_C_PORT DDRC
#define HIGH_C_PORT PORTC
#define HIGH_C 3

#define SET_LOW_C_PORT DDRB
#define LOW_C_PORT PORTB
#define LOW_C  0

//Are we using active low.
#define LOW_ACTIVE_LOW 0
#define HIGH_ACTIVE_LOW 1


//Also we need to setup the RC inputs

//RC Pins
#define SET_RC_PORT DDRD

#define RC_PORT PIND

#define RC_PIN  2

#define RC_LOW  260//150
#define RC_HIGH 480//400
#define RC_MID 370//275

/* There is also lots of connections for inputs from ADC and stuff but that can be added later
   if we want to be able to monitor battery voltage could also look at back EMF and some other stuff */

//RC Time variables 
#define DEADTIME 10
#define BUFFERTIME 40
#define MAXOUTTIME 20

//Do we want to be able to calibrate stuff
#define CALIBRATION 0

//Do you want EXPO Rates
#define EXPO 0

//Do you want TEMP LIMITING
#define TEMP_LIMIT 0

//Max Slew rate
#define MAX_SLEW  2 //Change in PWM 0-255 per clock tick (500Hz @ 8MHZ or 1Khz @ 16Mhz)

//Set temperature ADC Pin
#define TEMP_ADMUX 0b00000001  //ADC mux 1
#define I_AM_WARM 180
#define I_AM_HOT  170

//Define cpu speed
#define F_CPU 16000000UL

Die define RC Parameter hab ich mir schon angepasst
hat aber keine Auswirkung auf das andere Problem.
Deinen Vorschlag probier gleich noch aus.

[Andre Meschke (Gast)]

Die Zeile in der das time_diff steht hab ich den Wert wie du gesagt hast 
geändert auf 128. Ergebnis bei Überschreitung der 75% Schwelle wird der 
Motor langsamer.
Die 75% sind nur ein geschätzter Wert.

[Karl H. (kbuchegg)]

Hier

#define MAXOUTTIME 20

mach da mal eine 0 draus anstelle der 20

[Karl H. (kbuchegg)]

Andre Meschke schrieb:
> Die Zeile in der das time_diff steht hab ich den Wert wie du gesagt hast
> geändert auf 128. Ergebnis bei Überschreitung der 75% Schwelle wird der
> Motor langsamer.

Gut.
Dann bin ich mir recht sicher, dass das die bewusste Stelle ist.

Das scheint Absicht zu sein. Etwas für Rennfahrer, die immer Vollgas 
haben wollen, auch wenn der Knüppel im Eifer des Gefechts einmal aus der 
Endposition irrtümlich herausbewegt wird.

Also die 128 wieder auf 255 zurück ändern. Der Zweck der Übung (die 
Kontrolle) wurde ja erreicht.

[Andre Meschke (Gast)]

Der Code ist für Fighting Robots gedacht. Ich fahre aber ein Scale 
Schiffsmodell. Lässt sich das irgendwie ändern?

[Karl H. (kbuchegg)]

Andre Meschke schrieb:
> Der Code ist für Fighting Robots gedacht. Ich fahre aber ein Scale
> Schiffsmodell. Lässt sich das irgendwie ändern?

Sag ich doch
Beitrag "Re: C-Code für Fahrtregler anpassen"

[Andre Meschke (Gast)]

Hab jetzt im Hedaer folgende Zeile geändert
#define MAXOUTTIME 20
den Wert hab ich auf Null gesetzt, da gibt es dann fast keinen Sprung 
mehr.
Vielleicht hast du noch ne bessere Idee.

[Karl H. (kbuchegg)]

Andre Meschke schrieb:

> Vielleicht hast du noch ne bessere Idee.

Mehr sieht der Code nicht vor.
Kalibriere noch einmal, wobei du diesmal bei den Endwerten die Trimmung 
noch in der jeweiligen Richtung mit dazu nimmst. Wenn dein Sender eine 
Servoweg Einstellung erlaubt, kannst du auch mit der den Ausgabewert in 
der Vollgasposition ein wenig kleiner machen.

Für den Rest bräuchte man jetzt die konkreten Zahlen, die sich aus der 
Kalibrierung auf dem µC ergeben haben um einmal nachzurechnen, welche 
Werte sich hier

  desiredPWM = (time_diff - rcMid - deadzone)*256 / (rcHigh - rcMid - deadzone);

eigentlich ergeben und ob es da einen rechnerischen Zahlensprung gibt.
Die Zahlen wirst du aber nicht haben.

[Karl H. (kbuchegg)]

Karl H. schrieb:

>

>   desiredPWM = (time_diff - rcMid - deadzone)*256 / (rcHigh - rcMid - 
> deadzone);
>

Hmm.
Man könnte hier vielleicht noch eine Rundungskorrektur anbringen

  desiredPWM = (time_diff - rcMid - deadzone + ((rcHigh - rcMid - deadzone) / 2 ))*256 / (rcHigh - rcMid - deadzone) ;

Probier dann aber auch die kleinen Fahrstufen noch mit aus.
(UNd dann die Formel wieder etwas vereinfachen :-)

[Karl H. (kbuchegg)]

Karl H. schrieb:
> Karl H. schrieb:
>
>>

>>   desiredPWM = (time_diff - rcMid - deadzone)*256 / (rcHigh - rcMid -
>> deadzone);
>>

>
> Hmm.
> Man könnte hier vielleicht noch eine Rundungskorrektur anbringen
>

>   desiredPWM = (time_diff - rcMid - deadzone + ((rcHigh - rcMid - 
> deadzone) / 2 ))*256 / (rcHigh - rcMid - deadzone) ;
>

>
> Probier dann aber auch die kleinen Fahrstufen noch mit aus.
> (UNd dann die Formel wieder etwas vereinfachen :-)

What the heck. So rum wirds schon um einiges simpler

                    } else {
                        uint16_t divisor = rcHigh - rcMid - deadzone;
                        desiredPWM = (time_diff - rcMid - deadzone + divisor/2)*256 / divisor;
 ...

                        i

[Andre Meschke (Gast)]

Die letzte Vereinfachung raff ich zwar noch nicht ganz.
Die Werte der Kalibrierung hab ich ja

RC_LOW  260
RC_HIGH 480
RC_MID 370

An welche Stelle kommt das hier rein

 } else {
                        uint16_t divisor = rcHigh - rcMid - deadzone;
                        desiredPWM = (time_diff - rcMid - deadzone + 
divisor/2)*256 / divisor;

und was muss ich dafür entfernen

[Karl H. (kbuchegg)]

Andre Meschke schrieb:
> Die letzte Vereinfachung raff ich zwar noch nicht ganz.

Ich habe einfach nur den Ausdruck durch den dividiert wird in eine 
eigene Zwischenvariable geholt. Dies deshalb, damit ich den Nenner bei 
der Division noch die Hälfte davon dazuzählen kann ohne dass ich mir die 
Finger wund tippe. Eine sog. Rundungskorrektur.
In C wird bei Divisionen kein Nachkommaanteil beim rechnen mit Integern 
erzeugt. Die Division

6 / 7

ergibt eine glatte 0. Wenn ich aber das mit einem Taschenrechner 
ausrechne, dann bringt der 0.857.. raus. Und das liegt schon wesentlich 
näher an 1 als es an 0 liegt. D.h was ich gerne haben möchte, das ist 
das mir bei Divisionen, die einen Nachkommaanteil größer/gleich 0.5 
rausbringen würden, dann auch die nächst höhere Zahl als Ergebnis kommt. 
Eben so, wie wenn ich die 0.857 runden würde und 1.0 herausbringen 
würde.
Und dazu rechne ich nicht

   a
 ----- 
   b

sondern

   a
 ----- + 0.5
   b

dann kommt mir bei der Division

6 / 7  -> 0.857
0.857 + 0.5 -> 1.3357

heraus, und wenn man da die Nachkommastellen weglässt, dann erhalte ich 
die gewünschte 1

Aber: So will ich das nicht rechnen, weil ich ja keine 
Fliesskommaoperationen haben will. Aber ich kann ja die 0.5 auf den 
Bruchstrich hinaufziehen indem ich die 0.5 (oder eben 1/2) mit b 
erweitere. Und lande so bei

   a + b/2
  ---------
      b

und das kann ich wieder komplett mit ganzen Zahlen rechnen

   6 + 3        9
  -------  = -------
      7         7

( 3 ist die Hälfte von 7, wenn keine Nachkommastellen zugelassen sind)
und jetzt kommt auch wieder die gewünschte (gerundete, na ja) 1 heraus 
anstatt der ursprünglichen 0.
Habe ich statt dessen 2 / 7 zu rechnen, dann ist das Ergebnis

    2 + 3
  ---------
      7

und das ergibt 5 / 7 oder eben ausgerechnet eine glatte 0. Und das ist 
auch gut so, denn 2/7 oder in Fiesskomma gerechnet 0.28 liegt näher an 0 
als an 1.

> RC_LOW  260
> RC_HIGH 480
> RC_MID 370

Na dann setz die Zahlenwerte mal ein und rechne mal aus, was da dann für 
desiredPWM herauskommt.

> Die Werte der Kalibrierung hab ich ja

Woher hast du die? Waren die schon eingetragen?

-> Die müssen nicht notwendigerweise mit deiner Fernsteuerung 
zusammenpassen. Kalibrieren bedeutet, dass du den Regler in die 
Kalbrierung bringst, dann auf der Fernsteuerung deinen Knüppel in die 
Endposition bewegst und dem Regler mitteilst: das wars, jetzt ist der 
Knüppel in der Endposition, den Wert den du jetzt vermisst, dass ist der 
Wert der als Endposition gelten soll.

hast du das so gemacht und so die Werte ermittelt?

>  } else {
>                         uint16_t divisor = rcHigh - rcMid - deadzone;
>                         desiredPWM = (time_diff - rcMid - deadzone +
> divisor/2)*256 / divisor;
>
> und was muss ich dafür entfernen

Na da, wo vorher

                } else { //Else go forward
                    if (time_diff > (rcHigh - maxOut)) {
                        desiredPWM = 255;
                    } else {
                        desiredPWM = (time_diff - rcMid - deadzone)*256 / (rcHigh - rcMid - deadzone);
....
....

stand, da kommt jetzt

                } else { //Else go forward
                    if (time_diff > (rcHigh - maxOut)) {
                        desiredPWM = 255;
                    } else {
                        uint16_t divisor = rcHigh - rcMid - deadzone;
                        desiredPWM = (time_diff - rcMid - deadzone + divisor/2)*256 / divisor;
.....

Es ist seit Stunden immer die gleiche Codestelle.

[Karl H. (kbuchegg)]

Ui.
Das ist vielleicht ein Durcheinander in diesem Programm.
Auf der einen Seite gibt es eine Kalibrierfunktion, die irgendwelche 
Werte ermittelt und ins EEPROM schreibt. Auf der anderen Seite ist der 
Aufruf der Funktion, die die Kalbrierwerte aus dem EEPROM zum arbeiten 
holen sollte, auskommentiert.

So einen Saustall hab ich auch schon lange nicht mehr gesehen. Und das 
veröffentlicht jemand genau so?

[Karl H. (kbuchegg)]

DU könntest hier

RC_HIGH 480

noch probieren, den Wert etwas höher setzen. Sagen wir mal 485 oder 490.

[Andre Meschke (Gast)]

Ja das gibt es hier. War ein schönes Projekt. Aus preiswerten 
Brushlessreglern wurden Brushregler gemacht weil es die kaum noch 
preiswert gibt.
http://bazaar.launchpad.net/~brushed-team/brushed/trunk/files
Derjenige hat die Opensource Entwicklung eingestellt und vermarktet das 
jetzt hier.
http://botbitz.com.au/index.php?route=product/category&path=60

[Karl H. (kbuchegg)]

Andre Meschke schrieb:

> Derjenige hat die Opensource Entwicklung eingestellt und vermarktet das
> jetzt hier.
> http://botbitz.com.au/index.php?route=product/category&path=60

Dann wollen wir mal hoffen, dass sein Produktionscode in einem besseren 
Zustand ist.

[Matthias L. (Gast)]

Karl H. schrieb:
> So einen Saustall hab ich auch schon lange nicht mehr gesehen. Und das
> veröffentlicht jemand genau so?

Ja, wäre der Code in asm würde man sowas nur durch UVS erkennen ;-)

[Andre Meschke (Gast)]

OK ich glaub du hast recht da habe ich mir wohl den falschen Coder 
rausgesucht.
Hier ist noch ein in Assembler programmierter Code von jemand Anderem.
Auch der hat für mich nen kleinen Haken, ich hätte gern ein Deathband im 
Bereich zwischen 1179 und 1219 damit der Motor auch wirklich steht und 0 
Volt hat. Kann man in dem Assembler Code noch etwas ändern? Ein Paar 
Werte hab ich schon an meine Fernbedienung angepasst.

;--- Brushed ESC By Rolf R Bakke, May 2012

.include "m8def.inc"

.include "macros.inc"

.def  t=r16

.org 0
  ldi t, low(ramend)
  out spl, t
  ldi t, high(ramend)
  out sph, t


  ;--- Port setup ---

  ;        76543210
  ldi t, 0b11001100
  out ddrc, t

  ;        76543210
  ldi t, 0b11111111
  out ddrb, t

  ;        76543210
  ldi t, 0b10111011
  out ddrd, t


  ;--- PWM output setup ---

  ;        76543210
  ldi t, 0b10100000  
  out tccr1a, t

  ;        76543210
  ldi t, 0b00010001
  out tccr1b, t

  ldi t, high(255)  ;set PWM range
  out icr1h, t
  ldi t, low(255)
  out icr1l, t


  ;--- arming ---

ar2:  ldi zl, 0

ar1:  rcall GetPwm
  brcs ar2    ;time out, reset counter
  
  ldy 1159    ;1180 orginaler Wert im Code
  cp  xl, yl
  cpc xh, yh
  brlo ar2    ;too low, reset counter

  ldy 1239    ;1220 orginaler Wert im Code
  cp  xl, yl
  cpc xh, yh
  brsh ar2    ;too high, reset counter

  inc zl      ;in range, increase counter
  cpi zl, 50    ;50 in a row?
  brne ar1    ;no, arming not OK


  ;--- Main loop ---

ma1:  rcall GetPwm    ;get input PWM value

  subi xl, low(1199)  ;subtract 1500 uS    1200 orginaler Wert im Code 
  sbci xh, high(1199)            ;1200 orginaler Wert im Code

  brcs ma4    ;wich direction?


  ;--- forward ---

  clr t      ;turn off B half-bridge PWM
  out ocr1bh, t
  out ocr1bl, t
  rcall delay    ;wait one PWM cycle to let the B PWM hardware finish it current cycle
  a_top_off    ;set top transistors for forward configuration
  b_top_on
  out ocr1ah, xh    ;update A half-bridge with current throttle
  out ocr1al, xl

  rjmp ma1


  ;--- reverse ---

ma4:  clr yl      ;Y = NEG(X)
  clr yh
  sub yl, xl
  sbc yh, xh

  clr t      ;turn off A half-bridge PWM
  out ocr1ah, t
  out ocr1al, t
  rcall delay    ;wait one PWM cycle to let the A PWM hardware finish it current cycle
  b_top_off    ;set top transistors for reverse configuration
  a_top_on
  out ocr1bh, yh    ;update B half-bridge with current throttle
  out ocr1bl, yl

  rjmp ma1


  ;--- SUBS ---

  ;--- delay ----
  

delay:  ldi t, 0    ;96 uS delay
de1:  dec t
  brne de1
  ret

  

  ;--- get PWM input value ---


GetPwm:
  clr xl
  clr xh

  ;wait for low to high transition on ppm input

  ldy 0xffff
ge1:  sbiw y, 1
  brcs ge5  ;timeout (49mS)
  sbic pind, 2
  rjmp ge1

  ldy 0xffff    
ge2:  sbiw y,1
  brcs ge5  ;timeout (49mS)
  sbis pind, 2
  rjmp ge2

  ;measure high pulse time, 1.25 uS = 1 count

  ldy 8000
ge3:  adiw x, 1  ;2
  sbiw y, 1  ;2
  brcs ge5  ;1  ;exit with c=1 if timeout (10mS)
  nop    ;1
  nop    ;1
  sbic pind, 2  ;1
  rjmp ge3  ;2

  ;set to 1500uS if below 900uS or above 2100uS

  ldy 720
  cp  xl, yl
  cpc xh, yh
  brlo ge4  
  ldy 1680
  cp  xl, yl
  cpc xh, yh
  brlo ge6  

ge4:  ldx 1199    ;out of limits, set to 1500uS     1200 orginaler Wert im Code

  ;

ge6:  clc      ;exit with c=0 if no timeout
  ret

ge5:  ldx 1199    ;time out, set to 1500uS and c=1  1200 orginaler Wert im Code
  ret

Hier noch die Include Dateien:

.macro  a_top_on
  sbi portd, 4
.endmacro

.macro  a_top_off
  cbi portd, 4
.endmacro



.macro  b_top_on
  sbi portd, 5
.endmacro

.macro  b_top_off
  cbi portd, 5
.endmacro




.macro  ldx
  ldi xl, low(@0)
  ldi xh, high(@0)
.endmacro
.macro  ldy
  ldi yl, low(@0)
  ldi yh, high(@0)
.endmacro
.macro  ldz
  ldi zl, low(@0)
  ldi zh, high(@0)
.endmacro
 



.macro  debug_on
  sbi portb, 5
.endmacro

.macro  debug_off
  cbi portb, 5
.endmacro

;***** THIS IS A MACHINE GENERATED FILE - DO NOT EDIT ********************
;***** Created: 2011-08-25 21:00 ******* Source: ATmega8.xml *************
;*************************************************************************
;* A P P L I C A T I O N   N O T E   F O R   T H E   A V R   F A M I L Y
;* 
;* Number            : AVR000
;* File Name         : "m8def.inc"
;* Title             : Register/Bit Definitions for the ATmega8
;* Date              : 2011-08-25
;* Version           : 2.35
;* Support E-mail    : [e-mail]
;* Target MCU        : ATmega8
;* 
;* DESCRIPTION
;* When including this file in the assembly program file, all I/O register 
;* names and I/O register bit names appearing in the data book can be used.
;* In addition, the six registers forming the three data pointers X, Y and 
;* Z have been assigned names XL - ZH. Highest RAM address for Internal 
;* SRAM is also defined 
;* 
;* The Register names are represented by their hexadecimal address.
;* 
;* The Register Bit names are represented by their bit number (0-7).
;* 
;* Please observe the difference in using the bit names with instructions
;* such as "sbr"/"cbr" (set/clear bit in register) and "sbrs"/"sbrc"
;* (skip if bit in register set/cleared). The following example illustrates
;* this:
;* 
;* in    r16,PORTB             ;read PORTB latch
;* sbr   r16,(1<<PB6)+(1<<PB5) ;set PB6 and PB5 (use masks, not bit#)
;* out   PORTB,r16             ;output to PORTB
;* 
;* in    r16,TIFR              ;read the Timer Interrupt Flag Register
;* sbrc  r16,TOV0              ;test the overflow flag (use bit#)
;* rjmp  TOV0_is_set           ;jump if set
;* ...                         ;otherwise do something else
;*************************************************************************

#ifndef _M8DEF_INC_
#define _M8DEF_INC_


#pragma partinc 0

; ***** SPECIFY DEVICE ***************************************************
.device ATmega8
#pragma AVRPART ADMIN PART_NAME ATmega8
.equ  SIGNATURE_000  = 0x1e
.equ  SIGNATURE_001  = 0x93
.equ  SIGNATURE_002  = 0x07

#pragma AVRPART CORE CORE_VERSION V2E


; ***** I/O REGISTER DEFINITIONS *****************************************
; NOTE:
; Definitions marked "MEMORY MAPPED"are extended I/O ports
; and cannot be used with IN/OUT instructions
.equ  SREG  = 0x3f
.equ  SPL  = 0x3d
.equ  SPH  = 0x3e
.equ  GICR  = 0x3b
.equ  GIFR  = 0x3a
.equ  TIMSK  = 0x39
.equ  TIFR  = 0x38
.equ  SPMCR  = 0x37
.equ  TWCR  = 0x36
.equ  MCUCR  = 0x35
.equ  MCUCSR  = 0x34
.equ  TCCR0  = 0x33
.equ  TCNT0  = 0x32
.equ  OSCCAL  = 0x31
.equ  SFIOR  = 0x30
.equ  TCCR1A  = 0x2f
.equ  TCCR1B  = 0x2e
.equ  TCNT1L  = 0x2c
.equ  TCNT1H  = 0x2d
.equ  OCR1AL  = 0x2a
.equ  OCR1AH  = 0x2b
.equ  OCR1BL  = 0x28
.equ  OCR1BH  = 0x29
.equ  ICR1L  = 0x26
.equ  ICR1H  = 0x27
.equ  TCCR2  = 0x25
.equ  TCNT2  = 0x24
.equ  OCR2  = 0x23
.equ  ASSR  = 0x22
.equ  WDTCR  = 0x21
.equ  UBRRH  = 0x20
.equ  UCSRC  = 0x20
.equ  EEARL  = 0x1e
.equ  EEARH  = 0x1f
.equ  EEDR  = 0x1d
.equ  EECR  = 0x1c
.equ  PORTB  = 0x18
.equ  DDRB  = 0x17
.equ  PINB  = 0x16
.equ  PORTC  = 0x15
.equ  DDRC  = 0x14
.equ  PINC  = 0x13
.equ  PORTD  = 0x12
.equ  DDRD  = 0x11
.equ  PIND  = 0x10
.equ  SPDR  = 0x0f
.equ  SPSR  = 0x0e
.equ  SPCR  = 0x0d
.equ  UDR  = 0x0c
.equ  UCSRA  = 0x0b
.equ  UCSRB  = 0x0a
.equ  UBRRL  = 0x09
.equ  ACSR  = 0x08
.equ  ADMUX  = 0x07
.equ  ADCSRA  = 0x06
.equ  ADCL  = 0x04
.equ  ADCH  = 0x05
.equ  TWDR  = 0x03
.equ  TWAR  = 0x02
.equ  TWSR  = 0x01
.equ  TWBR  = 0x00


; ***** BIT DEFINITIONS **************************************************

; ***** ANALOG_COMPARATOR ************
; SFIOR - Special Function IO Register
.equ  ACME  = 3  ; Analog Comparator Multiplexer Enable

; ACSR - Analog Comparator Control And Status Register
.equ  ACIS0  = 0  ; Analog Comparator Interrupt Mode Select bit 0
.equ  ACIS1  = 1  ; Analog Comparator Interrupt Mode Select bit 1
.equ  ACIC  = 2  ; Analog Comparator Input Capture Enable
.equ  ACIE  = 3  ; Analog Comparator Interrupt Enable
.equ  ACI  = 4  ; Analog Comparator Interrupt Flag
.equ  ACO  = 5  ; Analog Compare Output
.equ  ACBG  = 6  ; Analog Comparator Bandgap Select
.equ  ACD  = 7  ; Analog Comparator Disable


; ***** SPI **************************
; SPDR - SPI Data Register
.equ  SPDR0  = 0  ; SPI Data Register bit 0
.equ  SPDR1  = 1  ; SPI Data Register bit 1
.equ  SPDR2  = 2  ; SPI Data Register bit 2
.equ  SPDR3  = 3  ; SPI Data Register bit 3
.equ  SPDR4  = 4  ; SPI Data Register bit 4
.equ  SPDR5  = 5  ; SPI Data Register bit 5
.equ  SPDR6  = 6  ; SPI Data Register bit 6
.equ  SPDR7  = 7  ; SPI Data Register bit 7

; SPSR - SPI Status Register
.equ  SPI2X  = 0  ; Double SPI Speed Bit
.equ  WCOL  = 6  ; Write Collision Flag
.equ  SPIF  = 7  ; SPI Interrupt Flag

; SPCR - SPI Control Register
.equ  SPR0  = 0  ; SPI Clock Rate Select 0
.equ  SPR1  = 1  ; SPI Clock Rate Select 1
.equ  CPHA  = 2  ; Clock Phase
.equ  CPOL  = 3  ; Clock polarity
.equ  MSTR  = 4  ; Master/Slave Select
.equ  DORD  = 5  ; Data Order
.equ  SPE  = 6  ; SPI Enable
.equ  SPIE  = 7  ; SPI Interrupt Enable


; ***** EXTERNAL_INTERRUPT ***********
; GICR - General Interrupt Control Register
.equ  GIMSK  = GICR  ; For compatibility
.equ  IVCE  = 0  ; Interrupt Vector Change Enable
.equ  IVSEL  = 1  ; Interrupt Vector Select
.equ  INT0  = 6  ; External Interrupt Request 0 Enable
.equ  INT1  = 7  ; External Interrupt Request 1 Enable

; GIFR - General Interrupt Flag Register
.equ  INTF0  = 6  ; External Interrupt Flag 0
.equ  INTF1  = 7  ; External Interrupt Flag 1

; MCUCR - MCU Control Register
.equ  ISC00  = 0  ; Interrupt Sense Control 0 Bit 0
.equ  ISC01  = 1  ; Interrupt Sense Control 0 Bit 1
.equ  ISC10  = 2  ; Interrupt Sense Control 1 Bit 0
.equ  ISC11  = 3  ; Interrupt Sense Control 1 Bit 1


; ***** TIMER_COUNTER_0 **************
; TIMSK - Timer/Counter Interrupt Mask Register
.equ  TOIE0  = 0  ; Timer/Counter0 Overflow Interrupt Enable

; TIFR - Timer/Counter Interrupt Flag register
.equ  TOV0  = 0  ; Timer/Counter0 Overflow Flag

; TCCR0 - Timer/Counter0 Control Register
.equ  CS00  = 0  ; Clock Select0 bit 0
.equ  CS01  = 1  ; Clock Select0 bit 1
.equ  CS02  = 2  ; Clock Select0 bit 2

; TCNT0 - Timer Counter 0
.equ  TCNT00  = 0  ; Timer Counter 0 bit 0
.equ  TCNT01  = 1  ; Timer Counter 0 bit 1
.equ  TCNT02  = 2  ; Timer Counter 0 bit 2
.equ  TCNT03  = 3  ; Timer Counter 0 bit 3
.equ  TCNT04  = 4  ; Timer Counter 0 bit 4
.equ  TCNT05  = 5  ; Timer Counter 0 bit 5
.equ  TCNT06  = 6  ; Timer Counter 0 bit 6
.equ  TCNT07  = 7  ; Timer Counter 0 bit 7


; ***** TIMER_COUNTER_1 **************
; TIMSK - Timer/Counter Interrupt Mask Register
.equ  TOIE1  = 2  ; Timer/Counter1 Overflow Interrupt Enable
.equ  OCIE1B  = 3  ; Timer/Counter1 Output CompareB Match Interrupt Enable
.equ  OCIE1A  = 4  ; Timer/Counter1 Output CompareA Match Interrupt Enable
.equ  TICIE1  = 5  ; Timer/Counter1 Input Capture Interrupt Enable

; TIFR - Timer/Counter Interrupt Flag register
.equ  TOV1  = 2  ; Timer/Counter1 Overflow Flag
.equ  OCF1B  = 3  ; Output Compare Flag 1B
.equ  OCF1A  = 4  ; Output Compare Flag 1A
.equ  ICF1  = 5  ; Input Capture Flag 1

; TCCR1A - Timer/Counter1 Control Register A
.equ  WGM10  = 0  ; Waveform Generation Mode
.equ  PWM10  = WGM10  ; For compatibility
.equ  WGM11  = 1  ; Waveform Generation Mode
.equ  PWM11  = WGM11  ; For compatibility
.equ  FOC1B  = 2  ; Force Output Compare 1B
.equ  FOC1A  = 3  ; Force Output Compare 1A
.equ  COM1B0  = 4  ; Compare Output Mode 1B, bit 0
.equ  COM1B1  = 5  ; Compare Output Mode 1B, bit 1
.equ  COM1A0  = 6  ; Compare Ouput Mode 1A, bit 0
.equ  COM1A1  = 7  ; Compare Output Mode 1A, bit 1

; TCCR1B - Timer/Counter1 Control Register B
.equ  CS10  = 0  ; Prescaler source of Timer/Counter 1
.equ  CS11  = 1  ; Prescaler source of Timer/Counter 1
.equ  CS12  = 2  ; Prescaler source of Timer/Counter 1
.equ  WGM12  = 3  ; Waveform Generation Mode
.equ  CTC10  = WGM12  ; For compatibility
.equ  CTC1  = WGM12  ; For compatibility
.equ  WGM13  = 4  ; Waveform Generation Mode
.equ  CTC11  = WGM13  ; For compatibility
.equ  ICES1  = 6  ; Input Capture 1 Edge Select
.equ  ICNC1  = 7  ; Input Capture 1 Noise Canceler


; ***** TIMER_COUNTER_2 **************
; TIMSK - Timer/Counter Interrupt Mask register
.equ  TOIE2  = 6  ; Timer/Counter2 Overflow Interrupt Enable
.equ  OCIE2  = 7  ; Timer/Counter2 Output Compare Match Interrupt Enable

; TIFR - Timer/Counter Interrupt Flag Register
.equ  TOV2  = 6  ; Timer/Counter2 Overflow Flag
.equ  OCF2  = 7  ; Output Compare Flag 2

; TCCR2 - Timer/Counter2 Control Register
.equ  CS20  = 0  ; Clock Select bit 0
.equ  CS21  = 1  ; Clock Select bit 1
.equ  CS22  = 2  ; Clock Select bit 2
.equ  WGM21  = 3  ; Waveform Generation Mode
.equ  CTC2  = WGM21  ; For compatibility
.equ  COM20  = 4  ; Compare Output Mode bit 0
.equ  COM21  = 5  ; Compare Output Mode bit 1
.equ  WGM20  = 6  ; Waveform Genration Mode
.equ  PWM2  = WGM20  ; For compatibility
.equ  FOC2  = 7  ; Force Output Compare

; TCNT2 - Timer/Counter2
.equ  TCNT2_0  = 0  ; Timer/Counter 2 bit 0
.equ  TCNT2_1  = 1  ; Timer/Counter 2 bit 1
.equ  TCNT2_2  = 2  ; Timer/Counter 2 bit 2
.equ  TCNT2_3  = 3  ; Timer/Counter 2 bit 3
.equ  TCNT2_4  = 4  ; Timer/Counter 2 bit 4
.equ  TCNT2_5  = 5  ; Timer/Counter 2 bit 5
.equ  TCNT2_6  = 6  ; Timer/Counter 2 bit 6
.equ  TCNT2_7  = 7  ; Timer/Counter 2 bit 7

; OCR2 - Timer/Counter2 Output Compare Register
.equ  OCR2_0  = 0  ; Timer/Counter2 Output Compare Register Bit 0
.equ  OCR2_1  = 1  ; Timer/Counter2 Output Compare Register Bit 1
.equ  OCR2_2  = 2  ; Timer/Counter2 Output Compare Register Bit 2
.equ  OCR2_3  = 3  ; Timer/Counter2 Output Compare Register Bit 3
.equ  OCR2_4  = 4  ; Timer/Counter2 Output Compare Register Bit 4
.equ  OCR2_5  = 5  ; Timer/Counter2 Output Compare Register Bit 5
.equ  OCR2_6  = 6  ; Timer/Counter2 Output Compare Register Bit 6
.equ  OCR2_7  = 7  ; Timer/Counter2 Output Compare Register Bit 7

; ASSR - Asynchronous Status Register
.equ  TCR2UB  = 0  ; Timer/counter Control Register2 Update Busy
.equ  OCR2UB  = 1  ; Output Compare Register2 Update Busy
.equ  TCN2UB  = 2  ; Timer/Counter2 Update Busy
.equ  AS2  = 3  ; Asynchronous Timer/counter2

; SFIOR - Special Function IO Register
.equ  PSR2  = 1  ; Prescaler Reset Timer/Counter2


; ***** USART ************************
; UDR - USART I/O Data Register
.equ  UDR0  = 0  ; USART I/O Data Register bit 0
.equ  UDR1  = 1  ; USART I/O Data Register bit 1
.equ  UDR2  = 2  ; USART I/O Data Register bit 2
.equ  UDR3  = 3  ; USART I/O Data Register bit 3
.equ  UDR4  = 4  ; USART I/O Data Register bit 4
.equ  UDR5  = 5  ; USART I/O Data Register bit 5
.equ  UDR6  = 6  ; USART I/O Data Register bit 6
.equ  UDR7  = 7  ; USART I/O Data Register bit 7

; UCSRA - USART Control and Status Register A
.equ  USR  = UCSRA  ; For compatibility
.equ  MPCM  = 0  ; Multi-processor Communication Mode
.equ  U2X  = 1  ; Double the USART transmission speed
.equ  UPE  = 2  ; Parity Error
.equ  PE  = UPE  ; For compatibility
.equ  DOR  = 3  ; Data overRun
.equ  FE  = 4  ; Framing Error
.equ  UDRE  = 5  ; USART Data Register Empty
.equ  TXC  = 6  ; USART Transmitt Complete
.equ  RXC  = 7  ; USART Receive Complete

; UCSRB - USART Control and Status Register B
.equ  UCR  = UCSRB  ; For compatibility
.equ  TXB8  = 0  ; Transmit Data Bit 8
.equ  RXB8  = 1  ; Receive Data Bit 8
.equ  UCSZ2  = 2  ; Character Size
.equ  CHR9  = UCSZ2  ; For compatibility
.equ  TXEN  = 3  ; Transmitter Enable
.equ  RXEN  = 4  ; Receiver Enable
.equ  UDRIE  = 5  ; USART Data register Empty Interrupt Enable
.equ  TXCIE  = 6  ; TX Complete Interrupt Enable
.equ  RXCIE  = 7  ; RX Complete Interrupt Enable

; UCSRC - USART Control and Status Register C
.equ  UCPOL  = 0  ; Clock Polarity
.equ  UCSZ0  = 1  ; Character Size
.equ  UCSZ1  = 2  ; Character Size
.equ  USBS  = 3  ; Stop Bit Select
.equ  UPM0  = 4  ; Parity Mode Bit 0
.equ  UPM1  = 5  ; Parity Mode Bit 1
.equ  UMSEL  = 6  ; USART Mode Select
.equ  URSEL  = 7  ; Register Select

.equ  UBRRHI  = UBRRH  ; For compatibility

; ***** TWI **************************
; TWBR - TWI Bit Rate register
.equ  I2BR  = TWBR  ; For compatibility
.equ  TWBR0  = 0  ; 
.equ  TWBR1  = 1  ; 
.equ  TWBR2  = 2  ; 
.equ  TWBR3  = 3  ; 
.equ  TWBR4  = 4  ; 
.equ  TWBR5  = 5  ; 
.equ  TWBR6  = 6  ; 
.equ  TWBR7  = 7  ; 

; TWCR - TWI Control Register
.equ  I2CR  = TWCR  ; For compatibility
.equ  TWIE  = 0  ; TWI Interrupt Enable
.equ  I2IE  = TWIE  ; For compatibility
.equ  TWEN  = 2  ; TWI Enable Bit
.equ  I2EN  = TWEN  ; For compatibility
.equ  ENI2C  = TWEN  ; For compatibility
.equ  TWWC  = 3  ; TWI Write Collition Flag
.equ  I2WC  = TWWC  ; For compatibility
.equ  TWSTO  = 4  ; TWI Stop Condition Bit
.equ  I2STO  = TWSTO  ; For compatibility
.equ  TWSTA  = 5  ; TWI Start Condition Bit
.equ  I2STA  = TWSTA  ; For compatibility
.equ  TWEA  = 6  ; TWI Enable Acknowledge Bit
.equ  I2EA  = TWEA  ; For compatibility
.equ  TWINT  = 7  ; TWI Interrupt Flag
.equ  I2INT  = TWINT  ; For compatibility

; TWSR - TWI Status Register
.equ  I2SR  = TWSR  ; For compatibility
.equ  TWPS0  = 0  ; TWI Prescaler
.equ  TWS0  = TWPS0  ; For compatibility
.equ  I2GCE  = TWPS0  ; For compatibility
.equ  TWPS1  = 1  ; TWI Prescaler
.equ  TWS1  = TWPS1  ; For compatibility
.equ  TWS3  = 3  ; TWI Status
.equ  I2S3  = TWS3  ; For compatibility
.equ  TWS4  = 4  ; TWI Status
.equ  I2S4  = TWS4  ; For compatibility
.equ  TWS5  = 5  ; TWI Status
.equ  I2S5  = TWS5  ; For compatibility
.equ  TWS6  = 6  ; TWI Status
.equ  I2S6  = TWS6  ; For compatibility
.equ  TWS7  = 7  ; TWI Status
.equ  I2S7  = TWS7  ; For compatibility

; TWDR - TWI Data register
.equ  I2DR  = TWDR  ; For compatibility
.equ  TWD0  = 0  ; TWI Data Register Bit 0
.equ  TWD1  = 1  ; TWI Data Register Bit 1
.equ  TWD2  = 2  ; TWI Data Register Bit 2
.equ  TWD3  = 3  ; TWI Data Register Bit 3
.equ  TWD4  = 4  ; TWI Data Register Bit 4
.equ  TWD5  = 5  ; TWI Data Register Bit 5
.equ  TWD6  = 6  ; TWI Data Register Bit 6
.equ  TWD7  = 7  ; TWI Data Register Bit 7

; TWAR - TWI (Slave) Address register
.equ  I2AR  = TWAR  ; For compatibility
.equ  TWGCE  = 0  ; TWI General Call Recognition Enable Bit
.equ  TWA0  = 1  ; TWI (Slave) Address register Bit 0
.equ  TWA1  = 2  ; TWI (Slave) Address register Bit 1
.equ  TWA2  = 3  ; TWI (Slave) Address register Bit 2
.equ  TWA3  = 4  ; TWI (Slave) Address register Bit 3
.equ  TWA4  = 5  ; TWI (Slave) Address register Bit 4
.equ  TWA5  = 6  ; TWI (Slave) Address register Bit 5
.equ  TWA6  = 7  ; TWI (Slave) Address register Bit 6


; ***** WATCHDOG *********************
; WDTCR - Watchdog Timer Control Register
.equ  WDTCSR  = WDTCR  ; For compatibility
.equ  WDP0  = 0  ; Watch Dog Timer Prescaler bit 0
.equ  WDP1  = 1  ; Watch Dog Timer Prescaler bit 1
.equ  WDP2  = 2  ; Watch Dog Timer Prescaler bit 2
.equ  WDE  = 3  ; Watch Dog Enable
.equ  WDCE  = 4  ; Watchdog Change Enable
.equ  WDTOE  = WDCE  ; For compatibility


; ***** PORTB ************************
; PORTB - Port B Data Register
.equ  PORTB0  = 0  ; Port B Data Register bit 0
.equ  PB0  = 0  ; For compatibility
.equ  PORTB1  = 1  ; Port B Data Register bit 1
.equ  PB1  = 1  ; For compatibility
.equ  PORTB2  = 2  ; Port B Data Register bit 2
.equ  PB2  = 2  ; For compatibility
.equ  PORTB3  = 3  ; Port B Data Register bit 3
.equ  PB3  = 3  ; For compatibility
.equ  PORTB4  = 4  ; Port B Data Register bit 4
.equ  PB4  = 4  ; For compatibility
.equ  PORTB5  = 5  ; Port B Data Register bit 5
.equ  PB5  = 5  ; For compatibility
.equ  PORTB6  = 6  ; Port B Data Register bit 6
.equ  PB6  = 6  ; For compatibility
.equ  PORTB7  = 7  ; Port B Data Register bit 7
.equ  PB7  = 7  ; For compatibility

; DDRB - Port B Data Direction Register
.equ  DDB0  = 0  ; Port B Data Direction Register bit 0
.equ  DDB1  = 1  ; Port B Data Direction Register bit 1
.equ  DDB2  = 2  ; Port B Data Direction Register bit 2
.equ  DDB3  = 3  ; Port B Data Direction Register bit 3
.equ  DDB4  = 4  ; Port B Data Direction Register bit 4
.equ  DDB5  = 5  ; Port B Data Direction Register bit 5
.equ  DDB6  = 6  ; Port B Data Direction Register bit 6
.equ  DDB7  = 7  ; Port B Data Direction Register bit 7

; PINB - Port B Input Pins
.equ  PINB0  = 0  ; Port B Input Pins bit 0
.equ  PINB1  = 1  ; Port B Input Pins bit 1
.equ  PINB2  = 2  ; Port B Input Pins bit 2
.equ  PINB3  = 3  ; Port B Input Pins bit 3
.equ  PINB4  = 4  ; Port B Input Pins bit 4
.equ  PINB5  = 5  ; Port B Input Pins bit 5
.equ  PINB6  = 6  ; Port B Input Pins bit 6
.equ  PINB7  = 7  ; Port B Input Pins bit 7


; ***** PORTC ************************
; PORTC - Port C Data Register
.equ  PORTC0  = 0  ; Port C Data Register bit 0
.equ  PC0  = 0  ; For compatibility
.equ  PORTC1  = 1  ; Port C Data Register bit 1
.equ  PC1  = 1  ; For compatibility
.equ  PORTC2  = 2  ; Port C Data Register bit 2
.equ  PC2  = 2  ; For compatibility
.equ  PORTC3  = 3  ; Port C Data Register bit 3
.equ  PC3  = 3  ; For compatibility
.equ  PORTC4  = 4  ; Port C Data Register bit 4
.equ  PC4  = 4  ; For compatibility
.equ  PORTC5  = 5  ; Port C Data Register bit 5
.equ  PC5  = 5  ; For compatibility
.equ  PORTC6  = 6  ; Port C Data Register bit 6
.equ  PC6  = 6  ; For compatibility

; DDRC - Port C Data Direction Register
.equ  DDC0  = 0  ; Port C Data Direction Register bit 0
.equ  DDC1  = 1  ; Port C Data Direction Register bit 1
.equ  DDC2  = 2  ; Port C Data Direction Register bit 2
.equ  DDC3  = 3  ; Port C Data Direction Register bit 3
.equ  DDC4  = 4  ; Port C Data Direction Register bit 4
.equ  DDC5  = 5  ; Port C Data Direction Register bit 5
.equ  DDC6  = 6  ; Port C Data Direction Register bit 6

; PINC - Port C Input Pins
.equ  PINC0  = 0  ; Port C Input Pins bit 0
.equ  PINC1  = 1  ; Port C Input Pins bit 1
.equ  PINC2  = 2  ; Port C Input Pins bit 2
.equ  PINC3  = 3  ; Port C Input Pins bit 3
.equ  PINC4  = 4  ; Port C Input Pins bit 4
.equ  PINC5  = 5  ; Port C Input Pins bit 5
.equ  PINC6  = 6  ; Port C Input Pins bit 6


; ***** PORTD ************************
; PORTD - Port D Data Register
.equ  PORTD0  = 0  ; Port D Data Register bit 0
.equ  PD0  = 0  ; For compatibility
.equ  PORTD1  = 1  ; Port D Data Register bit 1
.equ  PD1  = 1  ; For compatibility
.equ  PORTD2  = 2  ; Port D Data Register bit 2
.equ  PD2  = 2  ; For compatibility
.equ  PORTD3  = 3  ; Port D Data Register bit 3
.equ  PD3  = 3  ; For compatibility
.equ  PORTD4  = 4  ; Port D Data Register bit 4
.equ  PD4  = 4  ; For compatibility
.equ  PORTD5  = 5  ; Port D Data Register bit 5
.equ  PD5  = 5  ; For compatibility
.equ  PORTD6  = 6  ; Port D Data Register bit 6
.equ  PD6  = 6  ; For compatibility
.equ  PORTD7  = 7  ; Port D Data Register bit 7
.equ  PD7  = 7  ; For compatibility

; DDRD - Port D Data Direction Register
.equ  DDD0  = 0  ; Port D Data Direction Register bit 0
.equ  DDD1  = 1  ; Port D Data Direction Register bit 1
.equ  DDD2  = 2  ; Port D Data Direction Register bit 2
.equ  DDD3  = 3  ; Port D Data Direction Register bit 3
.equ  DDD4  = 4  ; Port D Data Direction Register bit 4
.equ  DDD5  = 5  ; Port D Data Direction Register bit 5
.equ  DDD6  = 6  ; Port D Data Direction Register bit 6
.equ  DDD7  = 7  ; Port D Data Direction Register bit 7

; PIND - Port D Input Pins
.equ  PIND0  = 0  ; Port D Input Pins bit 0
.equ  PIND1  = 1  ; Port D Input Pins bit 1
.equ  PIND2  = 2  ; Port D Input Pins bit 2
.equ  PIND3  = 3  ; Port D Input Pins bit 3
.equ  PIND4  = 4  ; Port D Input Pins bit 4
.equ  PIND5  = 5  ; Port D Input Pins bit 5
.equ  PIND6  = 6  ; Port D Input Pins bit 6
.equ  PIND7  = 7  ; Port D Input Pins bit 7


; ***** EEPROM ***********************
; EEDR - EEPROM Data Register
.equ  EEDR0  = 0  ; EEPROM Data Register bit 0
.equ  EEDR1  = 1  ; EEPROM Data Register bit 1
.equ  EEDR2  = 2  ; EEPROM Data Register bit 2
.equ  EEDR3  = 3  ; EEPROM Data Register bit 3
.equ  EEDR4  = 4  ; EEPROM Data Register bit 4
.equ  EEDR5  = 5  ; EEPROM Data Register bit 5
.equ  EEDR6  = 6  ; EEPROM Data Register bit 6
.equ  EEDR7  = 7  ; EEPROM Data Register bit 7

; EECR - EEPROM Control Register
.equ  EERE  = 0  ; EEPROM Read Enable
.equ  EEWE  = 1  ; EEPROM Write Enable
.equ  EEMWE  = 2  ; EEPROM Master Write Enable
.equ  EEWEE  = EEMWE  ; For compatibility
.equ  EERIE  = 3  ; EEPROM Ready Interrupt Enable


; ***** CPU **************************
; SREG - Status Register
.equ  SREG_C  = 0  ; Carry Flag
.equ  SREG_Z  = 1  ; Zero Flag
.equ  SREG_N  = 2  ; Negative Flag
.equ  SREG_V  = 3  ; Two's Complement Overflow Flag
.equ  SREG_S  = 4  ; Sign Bit
.equ  SREG_H  = 5  ; Half Carry Flag
.equ  SREG_T  = 6  ; Bit Copy Storage
.equ  SREG_I  = 7  ; Global Interrupt Enable

; MCUCR - MCU Control Register
;.equ  ISC00  = 0  ; Interrupt Sense Control 0 Bit 0
;.equ  ISC01  = 1  ; Interrupt Sense Control 0 Bit 1
;.equ  ISC10  = 2  ; Interrupt Sense Control 1 Bit 0
;.equ  ISC11  = 3  ; Interrupt Sense Control 1 Bit 1
.equ  SM0  = 4  ; Sleep Mode Select
.equ  SM1  = 5  ; Sleep Mode Select
.equ  SM2  = 6  ; Sleep Mode Select
.equ  SE  = 7  ; Sleep Enable

; MCUCSR - MCU Control And Status Register
.equ  MCUSR  = MCUCSR  ; For compatibility
.equ  PORF  = 0  ; Power-on reset flag
.equ  EXTRF  = 1  ; External Reset Flag
.equ  BORF  = 2  ; Brown-out Reset Flag
.equ  WDRF  = 3  ; Watchdog Reset Flag

; OSCCAL - Oscillator Calibration Value
.equ  CAL0  = 0  ; Oscillator Calibration Value Bit0
.equ  CAL1  = 1  ; Oscillator Calibration Value Bit1
.equ  CAL2  = 2  ; Oscillator Calibration Value Bit2
.equ  CAL3  = 3  ; Oscillator Calibration Value Bit3
.equ  CAL4  = 4  ; Oscillator Calibration Value Bit4
.equ  CAL5  = 5  ; Oscillator Calibration Value Bit5
.equ  CAL6  = 6  ; Oscillator Calibration Value Bit6
.equ  CAL7  = 7  ; Oscillator Calibration Value Bit7

; SPMCR - Store Program Memory Control Register
.equ  SPMEN  = 0  ; Store Program Memory Enable
.equ  PGERS  = 1  ; Page Erase
.equ  PGWRT  = 2  ; Page Write
.equ  BLBSET  = 3  ; Boot Lock Bit Set
.equ  RWWSRE  = 4  ; Read-While-Write Section Read Enable
.equ  RWWSB  = 6  ; Read-While-Write Section Busy
.equ  SPMIE  = 7  ; SPM Interrupt Enable

; SFIOR - Special Function IO Register
.equ  PSR10  = 0  ; Prescaler Reset Timer/Counter1 and Timer/Counter0
.equ  PUD  = 2  ; Pull-up Disable
.equ  ADHSM  = 4  ; ADC High Speed Mode


; ***** AD_CONVERTER *****************
; ADMUX - The ADC multiplexer Selection Register
.equ  MUX0  = 0  ; Analog Channel and Gain Selection Bits
.equ  MUX1  = 1  ; Analog Channel and Gain Selection Bits
.equ  MUX2  = 2  ; Analog Channel and Gain Selection Bits
.equ  MUX3  = 3  ; Analog Channel and Gain Selection Bits
.equ  ADLAR  = 5  ; Left Adjust Result
.equ  REFS0  = 6  ; Reference Selection Bit 0
.equ  REFS1  = 7  ; Reference Selection Bit 1

; ADCSRA - The ADC Control and Status register
.equ  ADCSR  = ADCSRA  ; For compatibility
.equ  ADPS0  = 0  ; ADC  Prescaler Select Bits
.equ  ADPS1  = 1  ; ADC  Prescaler Select Bits
.equ  ADPS2  = 2  ; ADC  Prescaler Select Bits
.equ  ADIE  = 3  ; ADC Interrupt Enable
.equ  ADIF  = 4  ; ADC Interrupt Flag
.equ  ADFR  = 5  ; ADC  Free Running Select
.equ  ADSC  = 6  ; ADC Start Conversion
.equ  ADEN  = 7  ; ADC Enable



; ***** LOCKSBITS ********************************************************
.equ  LB1  = 0  ; Lock bit
.equ  LB2  = 1  ; Lock bit
.equ  BLB01  = 2  ; Boot Lock bit
.equ  BLB02  = 3  ; Boot Lock bit
.equ  BLB11  = 4  ; Boot lock bit
.equ  BLB12  = 5  ; Boot lock bit


; ***** FUSES ************************************************************
; LOW fuse bits
.equ  CKSEL0  = 0  ; Select Clock Source
.equ  CKSEL1  = 1  ; Select Clock Source
.equ  CKSEL2  = 2  ; Select Clock Source
.equ  CKSEL3  = 3  ; Select Clock Source
.equ  SUT0  = 4  ; Select start-up time
.equ  SUT1  = 5  ; Select start-up time
.equ  BODEN  = 6  ; Brown out detector enable
.equ  BODLEVEL  = 7  ; Brown out detector trigger level

; HIGH fuse bits
.equ  BOOTRST  = 0  ; Select Reset Vector
.equ  BOOTSZ0  = 1  ; Select Boot Size
.equ  BOOTSZ1  = 2  ; Select Boot Size
.equ  EESAVE  = 3  ; EEPROM memory is preserved through chip erase
.equ  CKOPT  = 4  ; Oscillator Options
.equ  SPIEN  = 5  ; Enable Serial programming and Data Downloading
.equ  WTDON  = 6  ; Enable watchdog
.equ  RSTDISBL  = 7  ; Disable reset



; ***** CPU REGISTER DEFINITIONS *****************************************
.def  XH  = r27
.def  XL  = r26
.def  YH  = r29
.def  YL  = r28
.def  ZH  = r31
.def  ZL  = r30



; ***** DATA MEMORY DECLARATIONS *****************************************
.equ  FLASHEND  = 0x0fff  ; Note: Word address
.equ  IOEND  = 0x003f
.equ  SRAM_START  = 0x0060
.equ  SRAM_SIZE  = 1024
.equ  RAMEND  = 0x045f
.equ  XRAMEND  = 0x0000
.equ  E2END  = 0x01ff
.equ  EEPROMEND  = 0x01ff
.equ  EEADRBITS  = 9
#pragma AVRPART MEMORY PROG_FLASH 8192
#pragma AVRPART MEMORY EEPROM 512
#pragma AVRPART MEMORY INT_SRAM SIZE 1024
#pragma AVRPART MEMORY INT_SRAM START_ADDR 0x60



; ***** BOOTLOADER DECLARATIONS ******************************************
.equ  NRWW_START_ADDR  = 0xc00
.equ  NRWW_STOP_ADDR  = 0xfff
.equ  RWW_START_ADDR  = 0x0
.equ  RWW_STOP_ADDR  = 0xbff
.equ  PAGESIZE  = 32
.equ  FIRSTBOOTSTART  = 0xf80
.equ  SECONDBOOTSTART  = 0xf00
.equ  THIRDBOOTSTART  = 0xe00
.equ  FOURTHBOOTSTART  = 0xc00
.equ  SMALLBOOTSTART  = FIRSTBOOTSTART
.equ  LARGEBOOTSTART  = FOURTHBOOTSTART



; ***** INTERRUPT VECTORS ************************************************
.equ  INT0addr  = 0x0001  ; External Interrupt Request 0
.equ  INT1addr  = 0x0002  ; External Interrupt Request 1
.equ  OC2addr  = 0x0003  ; Timer/Counter2 Compare Match
.equ  OVF2addr  = 0x0004  ; Timer/Counter2 Overflow
.equ  ICP1addr  = 0x0005  ; Timer/Counter1 Capture Event
.equ  OC1Aaddr  = 0x0006  ; Timer/Counter1 Compare Match A
.equ  OC1Baddr  = 0x0007  ; Timer/Counter1 Compare Match B
.equ  OVF1addr  = 0x0008  ; Timer/Counter1 Overflow
.equ  OVF0addr  = 0x0009  ; Timer/Counter0 Overflow
.equ  SPIaddr  = 0x000a  ; Serial Transfer Complete
.equ  URXCaddr  = 0x000b  ; USART, Rx Complete
.equ  UDREaddr  = 0x000c  ; USART Data Register Empty
.equ  UTXCaddr  = 0x000d  ; USART, Tx Complete
.equ  ADCCaddr  = 0x000e  ; ADC Conversion Complete
.equ  ERDYaddr  = 0x000f  ; EEPROM Ready
.equ  ACIaddr  = 0x0010  ; Analog Comparator
.equ  TWIaddr  = 0x0011  ; 2-wire Serial Interface
.equ  SPMRaddr  = 0x0012  ; Store Program Memory Ready

.equ  INT_VECTORS_SIZE  = 19  ; size in words

#pragma AVRPART CORE INSTRUCTIONS_NOT_SUPPORTED break

#endif  /* _M8DEF_INC_ */

; ***** END OF FILE ******************************************************

Ich hoffe es kann mir jemand helfen. Kann leider keine 
Assemblerprogrammierung und C nur für den Hausgebrauch mit Arduino.

Grüße

Andre

[Karl H. (kbuchegg)]

Andre Meschke schrieb:

> Ich hoffe es kann mir jemand helfen. Kann leider keine
> Assemblerprogrammierung und C nur für den Hausgebrauch mit Arduino.

Aha. Und du glaubst das ist besser?

Wieso räumst du den C Code nicht einfach auf? Soooo schlecht ist der 
auch wieder nicht. Mit etwas drüber polieren könnte der ganz gut werden. 
Als erstes mal alles rauswerfen, was offenbar keine Funktion erfüllt. 
Dazu gehört die Kalibiermöglichkeit im Code und alles was damit 
zusammenhängt. Dann alles was auskommentiert ist - das verwirrt auf 
lange Sicht nur. Da ist dann schon ein guter Teil des Codes weggefallen. 
Und den Rest kann man analysieren, wie das zusammenhängt. Der ADC wird 
offenbar zur Überwachung eingesetzt. Wenn man das im Hinterkopf behält, 
dann kann man den auch erst mal rauswerfen. Dann bleibt schon nicht mehr 
viel übrig. Gerade mal die Logik um den Servopuls auszuwerten und daraus 
abgeleitet die Motor-PWM anzusteuern. Da ist dann noch eine 
Expo-Umrechung drinnen. Brauchst du die? Wenn nein, dann fliegt sie auch 
gleich mal raus. Die Motor-PWM Genererierung sollte dann nun wirklich 
nicht schwer zu verstehen bzw. zu modifizieren bzw. an deine 
Vorstellungen anzupassen sein. Dann sieht man sich an, ob man die 
Motorstromüberwachung noch haben will, dazu kommt dann der ADC wieder 
rein und gut ists. So schwer ist das auch wieder nicht bei einem 
Brushless-Motor. Im Prinzip ist das die Auswertung des Kanal-Pulses, der 
die Knüppelstellung wiederspiegelt und davon abgeleitet bzw. umgerechnet 
die Erzeugung einer PWM, welche die Fahrspannung steuert. Das ist nicht 
viel mehr als dein Dreisatz. Recht viel mehr braucht man dazu erst mal 
nicht. Der Softanlauf, damit die Motorspannung nicht schlagartig hoch 
bzw. runter geht ist nett und schont die Mechanik - und ist genauso 
simpel realisiert. Das ist ja grundsätzlich im vorliegenden Code alles 
in Ordnung. Er ist nur sehr unübersichtlich.

Auch mit Hausgebrauch Arduino kann man durchaus einen Motorregeler 
selbst programmieren, wenn man eine Vorlage hat, von der man sich 
abschauen kann, wie die einzelnen Teile beispielsweise gemacht werden.

Das ist sinnvoller als tagelang zu versuchen fremden Code in einzelnen 
Details an seine Wünsche anzupassen bzw. sich immer wieder neuen Code zu 
suchen, den man nicht versteht und der dann doch nicht die Stückeln 
spielt, die man haben will. Gerade in der Arduino Welt wird einem so 
etwas nun wirklich nicht schwer gemacht. Trau dich! Wenn du vor 
Weihnachten angefangen hättest, wärst du schon längst fertig und du 
würdest jedes einzelne Detail deines Reglers verstehen.