MausBeweger

/*
 * MausBeweger
 * 
 * Stepper-Ansteuerung inspiriert von: https://elektro.turanis.de/html/prj143/index.html
 * 
 * D.Ahlgrimm   15.10.2021
 */

#include <TimerOne.h>           // https://www.arduino.cc/reference/en/libraries/timerone/

#define PIN_COIL_IN1 8              // Spule blue
#define PIN_COIL_IN2 9              // Spule pink
#define PIN_COIL_IN3 10             // Spule yellow
#define PIN_COIL_IN4 11             // Spule orange
#define PIN_BUTTON   3              // Taster
#define PIN_LED     13              // LED

#define MOTOR_SPEED   10            // in Millisekunden

#define BUTTON_OPEN           0
#define BUTTON_PRESSED_SHORT  1
#define BUTTON_PRESSED_LONG   2
#define BUTTON_RELEASED_SHORT 3
#define BUTTON_RELEASED_LONG  4
volatile byte button=BUTTON_OPEN;   // aktueller Zustand des Tasters

#define LED_OFF         0           // nicht verwendet
#define LED_ON          1           // Geraet an - aber Stepper gerade inaktiv
#define LED_BLINK_FAST  2           // Stepper aktiv
#define LED_BLINK_SLOW  3           // Schlafmodus
volatile byte led_preset=LED_ON;    // aktueller LED-Modus

#define DEBUG false

const byte coil_pin[4] = { PIN_COIL_IN1, PIN_COIL_IN2, PIN_COIL_IN3, PIN_COIL_IN4 };

const bool coil_pwr[9][4] = {       // Soll-Zustaende der Spulen am Stepper
    {  LOW,  LOW,  LOW, HIGH },
    {  LOW,  LOW, HIGH, HIGH },
    {  LOW,  LOW, HIGH,  LOW },
    {  LOW, HIGH, HIGH,  LOW },
    {  LOW, HIGH,  LOW,  LOW },
    { HIGH, HIGH,  LOW,  LOW },
    { HIGH,  LOW,  LOW,  LOW },
    { HIGH,  LOW,  LOW, HIGH },
    {  LOW,  LOW,  LOW,  LOW }      // Stepper = aus
};

volatile bool stepper_on=true;      // steuert den Ein/Aus-Zustand des Steppers
volatile byte stepper_force_cnt=0;  // fuer Stepper 3x Hin-/Her nach kurzem Betaetigen des Tasters

// --------------------------------------------------------------------------------
// Wird einmal pro Millisekunde aufgerufen.
void per_ms(void) {
    static bool led_state;                      // An/Aus-Zustand der LED
    static bool led_slow_on=true;               // zum asynchronen Blinkverhaeltnis beim langsamen Blinken
    static int led_slow_on_cnt;                 // Zaehler fuer das asynchrone Blinkverhaeltnis
    static byte but_last=1;                     // Aenderungserkennung beim Taster
    static byte but_state=HIGH;                 // Zustand des Tasters, HIGH=offen, LOW=gedrueckt
    static unsigned long button_pressed=0L;     // Timeout-Wert fuer den Taster (Erkennung fuer "lange gedrueckt")

    // - - - - - - - - - - - - - - - - - - - - -
    // LED-Steuerung
    // - - - - - - - - - - - - - - - - - - - - -
    switch(led_preset) {
        case LED_OFF:
            led_state=LOW;
            break;
        case LED_ON:
            led_state=HIGH;
            break;
        case LED_BLINK_FAST:
            if(millis()%50==0) {
                led_state=!led_state;           // schnelles Flackern
            }
            break;
        case LED_BLINK_SLOW:
            if(millis()%3000==0) {
                led_slow_on=!led_slow_on;       // asynchrone Blinken (alle drei Sekunden kurz aufblinken)
                if(led_slow_on) {
                    led_slow_on_cnt=0;
                    led_state=HIGH;
                } else {
                    led_state=LOW;
                }
            }
            break;
    }
    if(led_preset==LED_BLINK_SLOW && led_slow_on) {
        led_slow_on_cnt++;
        if(led_slow_on_cnt>30) {                // beim asynchronen Blinken wird die An-Phase nach 30ms...
            led_state=LOW;                      // ...beendet.
        }
    }
    digitalWrite(PIN_LED, led_state);

    // - - - - - - - - - - - - - - - - - - - - -
    // Abfrage und Verarbeitung des Tasters
    // - - - - - - - - - - - - - - - - - - - - -
    but_state=digitalRead(PIN_BUTTON);
    if(but_state==LOW && button==BUTTON_PRESSED_SHORT) {        // wenn der Taster gedrueckt ist und davor auch schon gedrueckt war...
        if(button_pressed>0L && millis()>button_pressed) {      // ...und der Taster bereits seit einer Sekunde gedrueckt gehalten wird...
            button=BUTTON_PRESSED_LONG;                         // ...diesen Umstand vermerken...
            button_pressed=0L;
            #if DEBUG
            Serial.println("long detected");
            #endif
        }
    }
    if(but_state!=but_last) {               // wenn sich der Status am Taster geaendert hat...
        but_last=but_state;
        #if DEBUG
        Serial.println("but changed");
        #endif
        switch(button) {
            case BUTTON_OPEN:                       // wenn der Taster nicht betaetigt war und jetzt betaetigt wurde...
                button=BUTTON_PRESSED_SHORT;        // ...merken (erstmal als "kurz gedrueckt")...
                button_pressed=millis()+1000;       // ...und die Lang-Drueck-Erkennung aufsetzen
                break;
            case BUTTON_PRESSED_SHORT:              // wenn der Taster kurz betaetigt war und jetzt losgelassen wurde...
                button=BUTTON_RELEASED_SHORT;       // ...mal kurz merken... wird nach Verarbeitung auf BUTTON_OPEN gesetzt
                break;
            case BUTTON_PRESSED_LONG:               // wenn der Taster lange betaetigt war und jetzt losgelassen wurde...
                button=BUTTON_RELEASED_LONG;        // ...wie zuvor
                break;
        }
    }

    if(button==BUTTON_RELEASED_SHORT) {             // wenn der Taster kurz betaetigt war und jetzt wieder losgelassen wurde...
        #if DEBUG
        Serial.println("BUTTON_RELEASED_SHORT");
        #endif
        stepper_on=true;                            // ...Stepper einschalten
        stepper_force_cnt=3;
        led_preset=LED_BLINK_FAST;
        button=BUTTON_OPEN;
    } else if(button==BUTTON_RELEASED_LONG) {       // wenn der Taster lange betaetigt war und jetzt wieder losgelassen wurde...
        #if DEBUG
        Serial.println("BUTTON_RELEASED_LONG");
        #endif
        stepper_on=false;                           // Stepper aus und "Schlafmodus" einleiten
        led_preset=LED_BLINK_SLOW;
        button=BUTTON_OPEN;
    } else if(button==BUTTON_PRESSED_LONG) {        // wenn der Taster jetzt eine Sekunde lang betaetigt wurde...
        if(stepper_on) {                            // ...und der Stepper grade an ist - sofort ausschalten
            stepper_on=false;
            led_preset=LED_BLINK_SLOW;
        }
    }
}

// --------------------------------------------------------------------------------
// Init.
void setup() {
    for(int c=0; c<4; c++) {
        pinMode(coil_pin[c], OUTPUT);
    }
    pinMode(PIN_BUTTON, INPUT_PULLUP);
    pinMode(PIN_LED, OUTPUT);

    Timer1.initialize(1000);            // 1x pro Millisekunde
    Timer1.attachInterrupt(per_ms);

    #if DEBUG
    Serial.begin(115200);
    #endif
}

// --------------------------------------------------------------------------------
// Mainloop.
void loop() {
    static int i;
    static bool stepper_last=true;      // Aenderungserkennung am Stepper

    if(stepper_on) {
        moveMouse();
        for(i=0; i<3000 && stepper_on && stepper_force_cnt==0; i++) {   // 3000*10ms = 30 Sekunden Pause
            delay(10);
        }
        if(stepper_force_cnt>0) {
            stepper_force_cnt--;
            #if DEBUG
            Serial.print("stepper_force_cnt=");
            Serial.println(stepper_force_cnt);
            #endif
        }
    } else {
        if(stepper_last!=stepper_on) {
            stepper_last=stepper_on;
            stopMotor();
            #if DEBUG
            Serial.println("stopMotor()");
            #endif
        }
    }
    delay(10);
}

// --------------------------------------------------------------------------------
// Einen Hin-/Her-Dreher ausfuehren.
void moveMouse(void) {
    led_preset=LED_BLINK_FAST;
    for(int i=0; i<50; i++) {       // Drehung rechts
        rotateRight();
    }
    led_preset=LED_ON;
    stopMotor();                    // Strom sparen
    delay(100);

    led_preset=LED_BLINK_FAST;
    for(int i=0; i<50; i++) {       // Drehung links
        rotateLeft();
    }
    led_preset=LED_ON;
    stopMotor();                    // Strom sparen
}

// --------------------------------------------------------------------------------
// Acht Stepper-Schritte nach links.
void rotateRight(void) {
    if(!stepper_on) {   return;  }
    for(int c=0; c<8; c++) {
        //setMotor(coil_pwr[c]);
        setMotor(coil_pwr[c][0], coil_pwr[c][1], coil_pwr[c][2], coil_pwr[c][3]);
    }
}

// --------------------------------------------------------------------------------
// Acht Stepper-Schritte nach rechts.
void rotateLeft(void) {
    if(!stepper_on) {   return;  }
    for(int c=7; c>=0; c--) {
        //setMotor(coil_pwr[c]);
        setMotor(coil_pwr[c][0], coil_pwr[c][1], coil_pwr[c][2], coil_pwr[c][3]);
    }
}

// --------------------------------------------------------------------------------
// Die Stepper-Spulen stromlos machen.
void stopMotor() {
    //setMotor(coil_pwr[8]);
    setMotor(coil_pwr[8][0], coil_pwr[8][1], coil_pwr[8][2], coil_pwr[8][3]);
}

// --------------------------------------------------------------------------------
// Einen Stepper-Schritt ausfuehren.
// ...funktioniert...liefert aber Warnings.
void setMotor_alt(bool *coil_num) {
    for(int c=0; c<4; c++) {
        digitalWrite(coil_pin[c], coil_num[c]);
    }
    delay(MOTOR_SPEED);
}

// --------------------------------------------------------------------------------
// Einen Stepper-Schritt ausfuehren.
void setMotor(bool in1, bool in2, bool in3, bool in4) {
    digitalWrite(PIN_COIL_IN1, in1);
    digitalWrite(PIN_COIL_IN2, in2);
    digitalWrite(PIN_COIL_IN3, in3);
    digitalWrite(PIN_COIL_IN4, in4);
    delay(MOTOR_SPEED);
}
Pin	Belegung	Pin@ATmega328
1	frei	-
2	Taster	5
3	+5V	7
4	LED	19 (via 220 Ω)
5	GND	8, 22
MausBeweger

Inhaltsverzeichnis

Vorüberlegungen

Erste Tests

Und schon funktioniert es

Das Unterteil

Die Firmware (für den ATmega328)

Alles beisammen

Verlötung der Lochrasterplatte

Neues Oberteil
