/****************************************
* Strukturen der Motorsteuer-Firmware *
* sm1.cpp, sm2.cpp, sm3,cpp *
* heha, 140408 *
****************************************/
#pragma once
struct EeCtrl{ // Offset = 0: Kopfdaten
WORD fv; // Berechnungsschritte pro Sekunde für v (8 kHz)
char ea; // Exponent zur Basis 2 für a (64 kHz²)
char xs; // Irrelevante Bits für Positionsangabe (hier: Halbschritt)
BYTE le; // dies entspricht Load = 0 %
BYTE lf; // dies entspricht Load = 100 %
BYTE bd; // Baudrate gemäß Baudrate.htm
BYTE nm; // Achsen (Low-Nibble) à 48 Byte, Teiler für Bahnsteuerung (High-Nibble)
};
// Diese Struktur ist weitestgehend gleich der "struct Motor"-Struktur weiter unten.
// Um 4 Byte versetzt sowie ohne die PC-Angaben. Gesamtlänge: 48 Bytes
struct EeMotor{ // alle Positions- und Wegangaben in Mikroschritt
long Ist; // 04 00 Position zurzeit (wird häufiger geschrieben)
BYTE flags; // 08 04 Nichtflüchtige Bits
// 0 = LEFT Phasenumkehr der Motorbestromung
// 1 = REF Position referenziert
// 2 = RIGHT Default-Referenzschaltersuche zur Motorferne
// 3 = MANU Niemals Referenzfahrt, sondern Null-Setzung
// 4 = HOLD Dauer-Bestromung des Motors
// 5 = ROTA Umlaufender Antrieb ohne Endlagen
// 6 = PILG ¿Pilgern, sonst Spielausgleich
// 7 = AZ Zielfahrt nach Null nach Referenzfahrt
char MaxAccel; // 09 05 Maximale Beschleunigung (vzl.)
short MaxSpeed;// 0A 06 Maximal erlaubte Verfahrgeschwindigkeit (vzl.)
long RefPos; // 0C 08 Position des Referenzschalters ‡
long Anfang; // 10 0C Software-Endschalter links †
long Ende; // 14 10 Software-Endschalter rechts †
short Pilger; // 18 14 Pilgerschritte oder Spiel, vzb., max. ±127 Halbschritte
char Jerk; // 1A 16 (Maximaler) Ruck, 0 = ohne Ruckbegrenzung
BYTE endsw; // 1B 17 Endschalter-Zuweisung, Bits:
// 0 = Endschalter motornah vorhanden
// 1 = Endschalter motorfern vorhanden
// 2 = Referenzschalter vorhanden (gleiche Leitung wie „motornah“)
// 3 = Endschalter-Leitungen motornah/motorfern vertauscht
// 4 = Endschalter mit invertiertem Signal (Schließer)
BYTE fl2; // 1C 18 weitere Flags (Verbote)
// 4 = DEMO ¿ungenutzt
// 5 = F2AR ¿Automatisch Referenzfahrt beim Einschalten
// 6 = F2RR ¿Keine Bewegung ohne Referennz
// 7 = F2RV ¿Referenzverlust beim Einschalten
BYTE fl3; // 1D 19 unbestimmt
BYTE Current; // 1E 1A Strom durch Motorwicklung, in 20 mA (SM3+)
BYTE Curve; // 1F 1B Kurvenform der Sinusinterpolation (SM3+)
float PerUnit; // -- 1C Mikroschritt pro Einheit - nur für PC-Software
char Unit[8]; // -- 20 Einheitenbezeichner in UTF-8 - nur für PC-Software
// (nullterminiert oder nicht terminiert)
LONGLONG
FreeForApp; // -- 28 Handle o.ä. für Anwendungsprogramm
}; // Diese Struktur ist stückweise binärkompatibel mit „class Motor“:
// <RefPos> ist <Soll>; <ProEinheit> und <Einheit> kommen nicht vor
// † darf Inf sein, wenn Hardware-Endschalter vorhanden, sonst nicht.
// NaN ist nicht erlaubt.
// ‡ darf sich auch außerhalb von Anfang und Ende befinden.
// NaN oder Inf ist nicht erlaubt.
#define LNAN 0x80000000 // Not-a-number-Kode, keine oder ungültige Zahl, NaN
#define LINF 0x7FFFFFFF // Überlauf-Kode, +8
struct Motor { // Strukturgröße = 32 Bytes
enum { // Nur flüchtige Bits: BRAKE,FULL,PHA3, HUNT,REFF,SLOW
HUNT=1, // Ist an Soll angleichen („Jagd“-Modus), Zielfahrt
REFF=2, // Referenzfahrt (bis zum Referenz-Schalter)
BRAKE=4, // Bremsung aktiv (automatisch bei speed=0 gelöscht)
SLOW=8, // Langsame Schaltersuche (ggf. dritter Pass)
FULL=16, // voller Strom
}; // die übrigen 3 Bits = Halbschritt-Phase
BYTE phase; // 0 0..15; gerade Zahlen: geringer, ungerade: hoher Strom
char accel; // 1 0, +MaxAccel oder -MaxAccel, in Mikroschritt/(125µs)²*2^ea
short speed; // 2 ±MAXSPEED, mehr nicht! In Mikroschritt/125µs
long Ist; // 4 In Mikroschritt
enum { // Nur feste Bits: LEFT,RIGHT,MANU,HOLD,ROTA,AZ
LEFT=1, // Linkslauf (Motor dreht andersherum)
REF=2, // Referenzierte Position (Software-Endschalter wirksam)
RIGHT=4, // Schaltersuche nach rechts (zum Ende hin)
MANU=8, // niemals Referenzfahrt auf Anschlag (Konf.-Bit)
HOLD=16, // bestromt (kein Freilauf, aber reduzierter Strom)
ROTA=32, // umlaufender Antrieb ohne Endlagen (bspw. Spindel)
DEMO=64, // Demo-Modus (fährt zwischen den Endschaltern) — ungenutzt
AZ=128, // Auto-Zero = Nach Referenzfahrt zur Null eilen
}; // „Halbfeste“ Bits hierin sind REF und DEMO.
// Mögliche weitere Bits und Bytes:
// - Referenzierung beim Einschalten verlieren
// - Referenzpunkt beim Lösen des Schalters
// - Pilgerschritt (± Schritte)
BYTE flags; // 8 können per serielle Schnittstelle gesetzt werden
char MaxAccel; // 9 vzl. Maximalbeschleunigung, max. +MAXACCEL
short MaxSpeed;// 10 vzl. Maximalgeschwindigkeit für HUNT und REFF
long Soll; // 12 Sollposition, zu der hingefahren werden soll bei HUNT
#define RefDir ((char*)&Soll)[3] // +1 oder -1, Referenzfahrtrichtung
long Anfang; // 16 2 Software-Endschalter-Positionen (±8 erlaubt!), …
long Ende; // 20 … diese werden nur ausgewertet, wenn REF gesetzt ist
short Pilger; // 24
BYTE Jerk; // 26
BYTE endsw; // 27
BYTE fl2; // 28
BYTE fl3; // 29
BYTE pdc; // 30 PowerDownCounter (zz. ohne EEPROM-Startwert!)
char OneAccel; // 31 Einzel-Beschleunigungs-Befehl (wird in CalcSpeed null gesetzt)
// auch: Akkumulator für CalcSpeed-Zyklen
};
#pragma pack(1)
struct load_t{ // Antwort auf "#"
BYTE min;
BYTE max;
WORD avg;
};
struct move_t{ // Ist- oder Sollposition, Kommando "A".."F"
BYTE flags;
char accel;
short speed;
long pos;
};
struct read_t{ // Anfrage RAM/EEPROM/Flash lesen
BYTE cmd; // 0xA0 = Lesen
BYTE len; // = 4
WORD a; // Adresse
BYTE ah; // 0x00 = Flash, 0x80 = RAM, 0x81 = EEPROM
BYTE l; // Länge in Bytes, max. 255, 0 = nichts
};
struct write_t{ // Header RAM/EEPROM schreiben
BYTE cmd; // 0xA1 = Schreiben
BYTE len; // = Anzahl Bytes + 3
WORD a; // Adresse
BYTE ah; // 0x80 = RAM, 0x81 = EEPROM
}; // anschließend die Daten, max. 252 Bytes
struct ram_t{ // 28 Bytes aus Motor-Struktur im RAM
BYTE flags; // beginnt (absichtlich) so ähnlich wie move_t
char MaxAccel;
short MaxSpeed;
long Soll;
long Anfang,Ende;
short Pilger;
BYTE Jerk,endsw;
BYTE fl2,fl3;
BYTE pdc; // PowerDownCounter, nicht schreiben!
char OneAccel; // nicht schreiben!
};
#pragma pack()
| Vorgefundene Kodierung: UTF-8 | 0
|