...zuletzt der Code.
Mark, ich melde mich noch einmal per E-Mail bei dir.
Code:
#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
//**************************************************************
//Hardware-Konfiguration ATtiny45
//**************************************************************
#define LRChannel 2 // ADC für Links/Rechts-Poti
#define UDChannel 3 // ADC für Auf/Ab-Poti
#define PORT PORTB // I/O-Port Output-Register)
#define DDR DDRB // Data Direction Register
#define PIN PINB // I/O-Port (Input-Register)
#define PIN_DIR _BV(2) // Pin für Richtungsausgabe (Direction, CW/CCW)
#define PIN_CLK _BV(0) // Pin für Takt-Ausgabe
#define PIN_QUAD _BV(1) // Pin für Kennlinie (linear, quadratrisch)
#define PIN_LED _BV(5) // Pin für LED-Anzeige
//**************************************************************
//*** Daten des Joysticks
//**************************************************************
//Mittelstellung liegt bei einem Messwert von etwa 128 (+/-10)
//Minimum bei 3 (der Unterschied zu 0 ist vernachlässigbar)
//Maximum liegt bei 255
//**************************************************************
uint8_t LRZero = 0; //Null-Wert für LR-Kanal
uint8_t UDZero = 0; //Null-Wert für UD-Kanal
uint8_t LR = 0; //aktueller Messwert LR-Kanal
uint8_t UD = 0; //aktueller Messwert UD-Kanal
//**************************************************************
//*** Definitionen der Zonen
//**************************************************************
typedef enum
{ green, //beginnt bei etwa 1/3 des Ausschlags (128/3 = ca. 42, also 128-42=86, Nullpunktkorrektur nicht notwendig)
violett, //beginnt bei etwa 2/3 des Ausschlags (44)
yellow, //beginnt bei etwa 1/3 des Ausschlags (170)
orange, //beginnt bei etwa 2/3 des Ausschlags (212)
red, //beginnt bei etwa 1/6 des Ausschlags (1/8 = UDZero + 16 (Nullpunktskorrektor notwendig))
pink, //beginnt bei etwa 1/6 des Ausschlags (1/8 = UDZero - 16 (Nullpunktskorrektor notwendig))
white, //endet bei etwa 1/3 des LR-Ausschlags und 1/6 des UD-Ausschlags (s.o.)
blue //der Rest
} Zones;
// Beginn (ADC-Wert) der Zonen:
#define StartGreen 86
#define StartViolett 44
#define StartYellow 170
#define StartOrange 212
#define StartContZone 16
//**************************************************************
//*** Globale Variablen
//**************************************************************
volatile int8_t Direction = 0; // Richtung der Drehung (-1: links, 0: Stopp, 1: rechts) für kontinuierlichen Takt
volatile uint16_t LedCnt = 0; // ISR zählt auf 0 und schaltet dann LED aus.
volatile uint8_t OldSpeed = 0; // Merker für alte Geschwindigkeit (0 falls vorher Stopp)
volatile uint16_t OvfsCnt = 0; // Zähler für Geschwindigkeit. ISR zählt auf 0 und startet dann wieder mit OvfsFill.
// Bei 0 wird jewiels ein Taktimpuls von 0,256 ms Dauer erzeugt.
volatile uint16_t OvfsFill = 0; // Nach Ablauf einer Zählperiode wird wieder bei diesem Wert gestartet.
//**************************************************************
//*** Prototypen
//**************************************************************
uint8_t readADC(uint8_t channel); // ADC auslesen
Zones GetZone(void); // Zone ermitteln in der der Joystick steht
void HandleZones(void); // Statemachine für den Joystick
void DoSingleStep(int8_t Direction); // erzeugt einzelnes Clock-Signal
void SetSpeed(uint8_t Speed, int8_t Dir); // ermittelt die Timer-Paramter bei kontinuierlichem Takt
inline void LedOn(uint16_t ms) // Schaltet die LED für ms Millisekunden an
{ cli();
LedCnt = ms * 4;
sei();
}
inline void LedOff() // Schaltet die LED vorzeitig wieder aus
{ cli();
LedCnt = 0;
sei();
}
//**************************************************************
//*** Hauptprogramm
//**************************************************************
int main(void)
{ DDR |= PIN_DIR | PIN_CLK | PIN_LED; //Pins auf Output
PORT |= PIN_QUAD; //Pullup einschalten
//LED für ca. 1/2 Sec. an
_delay_ms(500);
PORT |= PIN_LED; //LED aus
TCCR0B |= _BV(CS01); //Timer aktivieren. Prescaler: 8. OVF-Int erfolgt alle 256µs (3.9 kHz) bei 8MHz Systemtakt
#if defined (__AVR_ATmega1284P__)
TIMSK0 |= _BV(TOIE0); //OVF-Interrupt freigeben
#else
TIMSK |= _BV(TOIE0); //OVF-Interrupt freigeben
#endif
sei(); // enable Interrupts
// ADC-Werte in Mittelstellung ermitteln
LRZero = readADC(LRChannel);
UDZero = readADC(UDChannel);
while(1) // immer wieder den Zustandsautomaten aufrufen
{ HandleZones();
}
}
//**************************************************************
//*** Zustandsautomat für Joystick-Bewegungen
//**************************************************************
void HandleZones(void)
{ Zones Zone = GetZone();
if((Zone != red) && (Zone != pink)) //Motor abschalten
{ Direction = 0;
OldSpeed = 0;
}
if(Zone == blue)
{ while (GetZone() != white); //Blau kann nur durch weiß aufgelöst werden.
return;
}
if(Zone == orange)
{ //SingleStep +
LedOn(150);
DoSingleStep(1);
while (GetZone() != white); //Weiß muss erreicht werden, bevor es weitergeht
LedOff();
return;
}
if(Zone == violett)
{ //SingleStep -
LedOn(150);
DoSingleStep(-1);
while (GetZone() != white); //Weiß muss erreicht werden, bevor es weitergeht
LedOff();
return;
}
if(Zone == red)
{ //SingleStep +
SetSpeed(UD - UDZero - StartContZone, 1);
return;
}
if(Zone == pink)
{ //SingleStep -
Direction = -1;
SetSpeed((UDZero - StartContZone) - UD, -1);
return;
}
}
//**************************************************************
//*** berechnet die Paramter für die Timer-ISR
//**************************************************************
//Speed: 0..112, proportional zur Auslenkung in den Zonen "Rot" und "Rosa" (256/2-StartContZone).
void SetSpeed(uint8_t Speed, int8_t Dir)
{ uint16_t SchrittFrequenz;
uint16_t OVFs;
if(Speed == 0)
Speed=1;
if(Speed > 112)
Speed = 112;
if(PIN & PIN_QUAD)
{ // quadratischer Verlauf
// Schrittfrequenz = 0,003 * Speed ^ 2 + 0,025 * Speed + 2
SchrittFrequenz = (uint32_t)3 * (uint32_t)Speed * (uint32_t)Speed / (uint32_t)1000 + (uint32_t)25 * (uint32_t)Speed / (uint32_t)1000 + 2;
}
else
{ // linearer Verlauf
// Schrittfrequenz = 0,36 * Speed + 2
SchrittFrequenz = (uint16_t) 36 * (uint16_t) Speed / (uint16_t)100 + 2;
}
//OVFs = Anzahl OVF-Interrupts für Periodendauer = 1.000.000 / 256 / Schrittfrequenz
OVFs = (uint16_t)3900 / SchrittFrequenz;
cli();
OvfsFill = OVFs;
if(OldSpeed)
{ if(OldSpeed > Speed) // soll langsamer werden
{/* if(OvfsCnt < OvfsFill)
OvfsCnt = OvfsFill; // Zeit verkürzen
Das würde dazu führen, dass bei zunehmender Verlangsamung OvfsCnt immer wieder mit neuen Werten geladen würde
und nie auf 0 kommen würde. Dass dies im gegengesetzen Fall (siehe nächstes "if") funktioniert, liegt am
asymetrischen Algorithmus. Der Timer zählt herunter!
*/
}
if(OldSpeed < Speed) // soll schneller werden
{ if(OvfsCnt > OvfsFill)
OvfsCnt = OvfsFill; // Zeit verkürzen
}
}
else
{ OvfsCnt = 1; // Bewirkt, dass nach einem Stopp der erste Takt unmittelbar erfolgt.
}
Direction = Dir;
sei();
OldSpeed = Speed;
}
//**************************************************************
//*** Ermittlung der Zone, in der der Joystick steht
//**************************************************************
Zones GetZone()
{ LR = readADC(LRChannel);
UD = readADC(UDChannel);
if((UD < UDZero + StartContZone) && (UD > UDZero - StartContZone)) // Test auf violett, grün, gelb und orange
{ if(LR < StartViolett)
return violett;
if(LR < StartGreen)
return green;
if(LR > StartOrange)
return orange;
if(LR > StartYellow)
return yellow;
return white;
}
if ((LR > StartGreen) && (LR < StartYellow))
{ if (UD >= UDZero + StartContZone)
return red;
else
return pink;
}
return blue;
}
//**************************************************************
//*** ADC auslesen
//**************************************************************
uint8_t readADC(uint8_t channel)
{ uint8_t i;
uint16_t result = 0;
// Den ADC aktivieren und Teilungsfaktor auf 64 stellen
ADCSRA = (1<<ADEN) | (1<<ADPS2) | (1<<ADPS1);
// Kanal des Multiplexers wählen
// VCC als Referenzspannung verwenden (also ca. 5V)
ADMUX = channel | (0<<REFS1) | (0<<REFS0);
// Den ADC initialisieren und einen sog. Dummyreadout machen
ADCSRA |= (1<<ADSC);
while(ADCSRA & (1<<ADSC));
// Jetzt 3x die analoge Spannung and Kanal channel auslesen
// und dann Durchschnittswert ausrechnen.
for(i=0; i<3; i++)
{ //Eine Wandlung
ADCSRA |= (1<<ADSC);
// Auf Ergebnis warten...
while(ADCSRA & (1<<ADSC));
result += ADCW/4;
} // for
// ADC wieder deaktivieren
ADCSRA &= ~(1<<ADEN);
result /= 3;
return (uint8_t)result;
} // readADC
//**************************************************************
// EinzelSchritt durchführen
//**************************************************************
void DoSingleStep(int8_t Direction)
{ //Direction setzen
if(Direction > 0)
PORT |= PIN_DIR;
else
PORT &= ~PIN_DIR;
_delay_us(10);
//Puls für Schritt ausgeben (Pulslänge 0.256 ms)
PORT |= PIN_CLK;
_delay_us(256);
PORT &= ~PIN_CLK;
_delay_us(10);
}
//**************************************************************
//Die ISR regelt folgende zeitabhängigen Funktion
//Takterzeugung
//LED-Steuerung
//**************************************************************
ISR(TIMER0_OVF_vect)
{ if(LedCnt)
{ PORT &= ~PIN_LED;
LedCnt--;
}
else
PORT |= PIN_LED;
if(!Direction) //Direction ist 0, also Stopp. Keine Takte notwendig
return;
if(Direction > 0) //Direction Pin setzen
PORT |= PIN_DIR;
else
PORT &= ~PIN_DIR;
if(OvfsCnt == 0) //Puls für Schritt ausgeben (Pulslänge 0.256 ms = 1 OVF)
{ OvfsCnt = OvfsFill;
PORT |= PIN_CLK;
LedOn(50);
}
else
{ OvfsCnt--;
PORT &= ~PIN_CLK;
}
}
Zitieren
.
Benutzer, die dieses Thema gelesen haben: 0
Lesezeichen