BILD (Arduino-Code)

zurück zu BILD>

*******************************************************************************
*
* 2017 Martin Bircher und Félix Stampfli
*
********************************************************************************
*
* K.U.N.S.T
*
* Art installation controll software for Félix Stampfli
*
*
* AUTHOR : Martin Bircher
* COMPANY : Martin Bircher
* REVISION : 18_3
* DATE : 12/11/2017
*
*******************************************************************************/

/*******************************************************************************
* IO DEFINITIONEN *
*******************************************************************************/

// Geschwindigkeit (PWM) pin 5
const int pinPwm = 5;

// Richtung (DIR) pin 2
const int pinDir = 2;

// Radar pin 7
const int pinRadar = 7;

// Stop Button pin 9
const int pinStop = 9;

// Voice Modul pin 10
const int pinVoice = 10;

// Glocke pin 11
const int pinGlocke = 11;

// LED Strip pin 12
const int pinStrip = 12;

// Spot pin 13
const int pinSpot = 13;

// hier kommen dann noch die anderen sensoren zur erkennung der position

// Hallsensor 12 Uhr pin A0
const int pinHall12 = 0;

// Hallsensor 3 Uhr pin A1
const int pinHall3 = 1;

// Hallsensor 6 Uhr pin A2
const int pinHall6 = 2;

// Hallsensor 9 Uhr pin A3
const int pinHall9 = 3;

/*******************************************************************************
* BENUTZER VARIABELN (hier kann man schrauben) *
*******************************************************************************/

//LED blink Zeiten in Millisekunden ***
static long blinkAn = 4;
static long blinkAus = 135;

//Beschleunigs und Bremsrate (0.001-255 Schritte/Millisekunde)
float beschleunigungsrate = 0.02;
float bremsrate = 0.01;

//Geschwindigkeit mit welcher die endposition angefahren wird (1-255)
int endAnfahrGeschwindigkeit = 20;

//Kleinste mögliche geschwindigkeit bei welcher sich das ganze noch dreht
int absolutMinGeschwindigkeit = 18;

//Frequenz des PWM
static int pwmFrequenz = 2; //für Pin 5: 1-> normal (ca. 976 Hz), 2-> hoch (ca. 7812 Hz), 3-> Super Ninja (ca. 62 kHz)
//für Pin 3: 1-> normal (ca. 490 Hz), 2-> mittel (ca. 980 Hz), 3-> hoch (ca. 3.9 kHz, 4-> Ninja (ca. 31.3 kHz)

static int glaetten = 2; // Anzahl der letzten Werte, welche zur Glätung der Hallsensor Werte verwendet werden. (2 – 20)
static int nullDelay = 0; // Delay in Millisekunden zum Anfahren der Nullpunkte
static int sensorSchwelle = 600; // schwellwert bei welchem sicher ein Magnet beim Sensor erkannt wird.

/*******************************************************************************
* SYSTEM VARIABELN (die sollen so bleiben..) *
*******************************************************************************/

static boolean rechts = false;
static boolean links = true;
static int aus = 0;
static int ein = 1;
static int strobo = 2;
//static int homeTreshold = 1000; //(0-1023)

int ablaufSchritt = 1;
boolean newStep = true;
boolean corrStep = false;
boolean betrachterErkannt = false;
long waitTimer = 0;
int posCounter;
int lastPos;
int timeFactor = 1;
//int homeVal;

int testGeschwindigkeit = 0; // nur zum Testen

/*/////////////////////////////////////////////////////////////////////////////////////////////////////*//*/////////////////////////////////////////////////////////////////////////////////////////////////////*/
/*******************************************************************************
* KLASSEN (hier gibt’s nix zu tun) *
*******************************************************************************/

class Position
{
// Class Member Variables
// These are initialized at startup

// These maintain the current state
int val; // read sensor value
int values[20];
int valuesCounter; // used as index in the values array
int averaging; // the numbers of past values for averaging
int threshold; // the threshold for safly recognizing a magnet

// Constructor
// and initializes the member variables and state
public:
int sensor; // depending on which sensor is triggered (0 -> 12, 1 -> 3, 2 -> 6, 3 -> 9, 4 -> non)
int sensorPassed; // holds the value of the last sensor which was triggered (0 -> 12, 1 -> 3, 2 -> 6, 3 -> 9)
int toSpot; // devitaion from minimal voltage
int sensorCalibration[4] = {0, 0, 0, 0}; //Sensoren 12 – 3 – 6 – 9
bool calibration = false;

Position(int tempAveraging, int tempThreshold)
{
averaging = tempAveraging;
threshold = tempThreshold;
sensor = 4;
valuesCounter = 0;
for(int i=0; i < averaging; i++)
{
values[i] = 0;
}
}

void Get()
{
if(sensor == 4)
{
val = analogRead(0);
if(val >= threshold)
{
sensor = 0;
}
else
{
val = analogRead(1);
if(val >= threshold)
{
sensor = 1;
}
else
{
val = analogRead(2);
if(val >= threshold)
{
sensor = 2;
}
else
{
val = analogRead(3);
if(val >= threshold)
{
sensor = 3;
}
}
}
}
}
else
{
val = analogRead(sensor);
if(val < threshold)
{
sensor = 4;
}
}
values[valuesCounter++] = val*10;
//Serial.println(valuesCounter);
if(valuesCounter >= averaging)
{
valuesCounter = 0;
}
if(sensor != 4)
{
if(val > 650)
{
sensorPassed = sensor;
}
long average = 0;
for(int i=0; i < averaging; i++)
{
average += values[i];
}
average = average/averaging;
// here comes the deviation calculation
if(calibration)
{
if(average > sensorCalibration[sensor])
{
sensorCalibration[sensor] = average;
toSpot = 0;
//Serial.print(„New Calibration: „);
//Serial.println(average);
}
else
{
toSpot = sensorCalibration[sensor] – average;
}
}
else
{
toSpot = sensorCalibration[sensor] – average;
}
//Serial.print(„Sensor „);
//Serial.print(sensor);
//Serial.print(„, „);
//Serial.print(average);

//Serial.print(„, „);
//Serial.println(toSpot);
}
digitalWrite(4, HIGH); // this is for testing the frequency of getting new values
}
};
Position pos(glaetten, sensorSchwelle);

class LedController
{
// Class Member Variables
// These are initialized at startup
int ledPin; // the number of the LED pin
long OnTime; // milliseconds of on-time
long OffTime; // milliseconds of off-time

// These maintain the current state
int ledState; // ledState used to set the LED
int ledMode; // mode of LED 0 -> off, 1 -> on, 2-> blinking
unsigned long previousMillis; // will store last time LED was updated

// Constructor – creates a LedController
// and initializes the member variables and state
public:
LedController(int pin, long on, long off)
{
ledPin = pin;
pinMode(ledPin, OUTPUT);

OnTime = on;
OffTime = off;

ledState = LOW;
ledMode = 0;
previousMillis = 0;
}

void Set(int mode)
{
ledMode = mode;
}

void Update()
{
// check to see if it’s time to change the state of the LED
unsigned long currentMillis = millis() / timeFactor;
if(ledMode == 0 && ledState == HIGH)
{
ledState = LOW;
digitalWrite(ledPin, ledState);
}
else if(ledMode == 1 && ledState == LOW)
{
ledState = HIGH;
digitalWrite(ledPin, ledState);
}
else if(ledMode == 2 && ledState == HIGH && currentMillis – previousMillis >= OnTime)
{
ledState = LOW; // Turn it off
previousMillis = currentMillis; // Remember the time
digitalWrite(ledPin, ledState); // Update the actual LED
}
else if(ledMode == 2 && ledState == LOW && currentMillis – previousMillis >= OffTime)
{
ledState = HIGH; // turn it on
previousMillis = currentMillis; // Remember the time
digitalWrite(ledPin, ledState); // Update the actual LED
}
}
};
LedController led1(pinStrip, blinkAn, blinkAus);

class Motor
{
// Class Member Variables
// These are initialized at startup
int pwmPin; // the number of the PWM pin
int dirPin; // the number of the direction pin
float accRate; // acceleration rate 0-255 steps/ms
float decRate; // deceleration rate 0-255 steps/ms

// These maintain the current state
float currentSpeed; // the current speed of the motor
int targetSpeed; // speed after ac- or deceleration (0-255)
//boolean currentDirection; // direction of the motor true -> forward, false -> backward
boolean targetDirection; // direction after ac- or deceleration
unsigned long previousMillis; // will store last time Motor was updated

public:
boolean targetReached;
boolean currentDirection; // direction of the motor true -> forward, false -> backward

// Constructor – creates a Motor object
// and initializes the member variables and state
public:
Motor(int pin1, int pin2, float acc, float dec)
{
pwmPin = pin1;
pinMode(pwmPin, OUTPUT);

dirPin = pin2;
pinMode(dirPin, OUTPUT);

accRate = acc;
decRate = dec;

currentSpeed = 0;
targetSpeed = 0;
currentDirection = true;
targetDirection = true;
targetReached = true;
previousMillis = 0;
}

void Set(int ts, boolean d)
{
targetSpeed = ts;
targetDirection = d;
targetReached = false;
}

void Override(int ts)
{
targetSpeed = ts;
currentSpeed = targetSpeed;
targetReached = true;
}

void Update()
{
// check to see if it’s time to change the state of the Motor
unsigned long currentMillis = millis() / timeFactor;

if(currentSpeed == targetSpeed && currentDirection == targetDirection)
{
//all set
targetReached = true;
}
else
{
unsigned long diffMillis = currentMillis – previousMillis;
if(currentDirection != targetDirection || currentSpeed > targetSpeed) // needs to decelerate
{
currentSpeed -= diffMillis * decRate;
if(currentDirection != targetDirection && currentSpeed <= 0)
{
currentSpeed *= -1;
currentDirection = !currentDirection;
}
else if(currentDirection == targetDirection && currentSpeed < targetSpeed)
{
currentSpeed = targetSpeed;
}
}
else // needs to accelerate
{
currentSpeed += diffMillis * accRate;
if(currentSpeed > targetSpeed)
{
currentSpeed = targetSpeed;
}
}
}
analogWrite(pwmPin, currentSpeed);
digitalWrite(dirPin, currentDirection);
previousMillis = currentMillis;
}
};
Motor motor(pinPwm, pinDir, beschleunigungsrate, bremsrate);

/*/////////////////////////////////////////////////////////////////////////////////////////////////////*//*/////////////////////////////////////////////////////////////////////////////////////////////////////*/
/*******************************************************************************
* FUNKTIONEN (nur für die Augen) *
*******************************************************************************/

// setup läuft einmal nach dem start des Arduinos.
void setup() {

// Radar pin 7
pinMode(pinRadar, INPUT_PULLUP);

// Stop Button pin 9
pinMode(pinStop, INPUT_PULLUP);

// Voice Modul pin 10;
pinMode(pinVoice, OUTPUT);
digitalWrite(pinVoice, HIGH);

// Glocke pin 11;
pinMode(pinGlocke, OUTPUT);

// LED Strip pin 12;
pinMode(pinStrip, OUTPUT);

// Spot pin 13;
pinMode(pinSpot, OUTPUT);

if(pinPwm == 3)
{
switch (pwmFrequenz)
{
case 1:
TCCR2B = (TCCR2B & 0b11111000) | 0x04;
break;
case 2:
TCCR2B = (TCCR2B & 0b11111000) | 0x03;
break;
case 3:
TCCR2B = (TCCR2B & 0b11111000) | 0x02;
break;
case 4:
TCCR2B = (TCCR2B & 0b11111000) | 0x01;
break;
}
timeFactor = 1;
}
else if(pinPwm == 5)
{
switch (pwmFrequenz)
{
case 1:
TCCR0B = (TCCR0B & 0b11111000) | 0x03;
timeFactor = 1;
break;
case 2:
TCCR0B = (TCCR0B & 0b11111000) | 0x02;
timeFactor = 8;
break;
case 3:
TCCR0B = (TCCR0B & 0b11111000) | 0x01;
timeFactor = 64;
break;
}
}
analogReference(DEFAULT);
Serial.begin(9600);
ablaufSchritt = 0; // initialisiert den Test
}

// The loop routine runs over and over again forever.
void loop() {
pos.Get();
if(ablaufSchritt < 81 && digitalRead(pinStop) == LOW){ // Auschalten
//ablaufSchritt = 81;
}
ablauf();
led1.Update();
motor.Update();
}

/*/////////////////////////////////////////////////////////////////////////////////////////////////////*//*/////////////////////////////////////////////////////////////////////////////////////////////////////*/

void springeZumAnfang()
{
ablaufSchritt = 1;
}

void springeWeiter()
{
ablaufSchritt++;
}

void springeZuSchritt(int tempSchritt)
{
ablaufSchritt = tempSchritt;
}

void glocke(int anzahl)
{
for(int i = anzahl; i > 0; i–){
digitalWrite(pinGlocke, HIGH);
delay(170 * timeFactor);
digitalWrite(pinGlocke, LOW);
if(i > 1){
delay(500 * timeFactor);
}
}
ablaufSchritt++;
}

void voice()
{
digitalWrite(pinVoice, LOW);
delay(50 * timeFactor);
digitalWrite(pinVoice, HIGH);
ablaufSchritt++;
}

void licht(int mode)
{
if(mode == 1){
digitalWrite(pinSpot, HIGH);
} else {
digitalWrite(pinSpot, LOW);
}
}

void ledStrip(int mode)
{
led1.Set(mode);
}

bool betrachter()
{
int radarValue = digitalRead(pinRadar);
if(radarValue == HIGH) //niemand erkannt
{
return false;
}
else
{
return true;
}
}

void warte(int seconds)
{
if(newStep)
{
waitTimer = millis() / timeFactor + long(seconds) * 1000;
newStep = false;
}
else
{
if(ablaufSchritt <= 30){ // TEASER
if(betrachter()){
ablaufSchritt = 31; // gehe zu SPIEL
newStep = true;
return;
}
}
if(millis() / timeFactor >= waitTimer)
{
if(ablaufSchritt == 65 && betrachter()){ // ende vom FINALE und betrachter
ablaufSchritt = 31; // gehe zu SPIEL beginn
newStep = true;
return;
}
ablaufSchritt++;
newStep = true;
}
}
}

void geschwindigkeit(int targetSpeed, boolean targetDirection = true)
{
if(newStep)
{
motor.Set(targetSpeed, targetDirection);
newStep = false;
}
else
{
if(motor.targetReached)
{
ablaufSchritt++;
newStep = true;
}
}
}

void zuSensor(int targetPosition, boolean targetDirection, int correct)
{
if(newStep)
{
motor.Set(endAnfahrGeschwindigkeit, targetDirection);
newStep = false;
}
else if(corrStep)
{
if(correct > 0)
{
delay(200);
analogWrite(pinPwm, absolutMinGeschwindigkeit);
digitalWrite(pinDir, !targetDirection);
delay(correct);
analogWrite(pinPwm, 0);
digitalWrite(pinDir, targetDirection);
}
corrStep = false;
ablaufSchritt++;
newStep = true;
}
else
{
int endPos = targetPosition / 3;
if(endPos == 4)
{
endPos = 0;
}
int posNow = pos.sensor;
if(posNow == endPos) // is on right sensor
{
int toSpot = pos.toSpot; // 10230 – 0
long speed = long(endAnfahrGeschwindigkeit) * long(toSpot);
//Serial.println(speed);
speed = speed / (10230 – (sensorSchwelle * 10));
if(int(speed)<= absolutMinGeschwindigkeit)
{
speed = long(absolutMinGeschwindigkeit);
}
//Serial.println(speed);
//Serial.println(int(speed));
motor.Override(speed);
//nullDelay
if(toSpot <= 2)
{
delay(timeFactor * nullDelay);
motor.Override(0);
corrStep = true;
}
}
}
}

void drehen(int targetSpeed, boolean targetDirection, int minRotations, int targetPosition, int correct)
{
if(newStep)
{
motor.Set(targetSpeed, targetDirection);
int endPos = targetPosition / 3;
if(endPos == 4)
{
endPos = 0;
}
int startPos = pos.sensor;
lastPos = startPos;
int addSteps = 0;
if(startPos != endPos)
{
if(targetDirection) //CW
{
addSteps = endPos – startPos;
}
else //CCW
{
addSteps = startPos – endPos;
}
if(addSteps < 0)
{
addSteps += 4;
}
}
posCounter = (minRotations * 4) + addSteps;
newStep = false;
}
else if(corrStep)
{
if(correct > 0)
{
delay(200);
analogWrite(pinPwm, absolutMinGeschwindigkeit);
digitalWrite(pinDir, !targetDirection);
delay(correct);
analogWrite(pinPwm, 0);
digitalWrite(pinDir, targetDirection);
}
corrStep = false;
ablaufSchritt++;
newStep = true;
}
else
{
if(posCounter > 0)
{
int posNow = pos.sensor;
if(posNow != 4) // is on sensor
{
if(posNow != lastPos)
{
//Serial.print(„Sensor „);
//Serial.println(posNow);
posCounter–;
lastPos = posNow;
}
if(posCounter <= 5) // brake
{
motor.Set(endAnfahrGeschwindigkeit, motor.currentDirection);
}
}
}
else //stop
{
int toSpot = pos.toSpot; // 10230 – 0
long speed = long(endAnfahrGeschwindigkeit) * long(toSpot);
//Serial.println(speed);
speed = speed / (10230 – (sensorSchwelle * 10));
if(int(speed)<= absolutMinGeschwindigkeit)
{
speed = long(absolutMinGeschwindigkeit);
}
//Serial.println(speed);
//Serial.println(int(speed));
motor.Override(speed);
//nullDelay
if(toSpot <= 2)
{
delay(timeFactor * nullDelay);
motor.Override(0);
corrStep = true;
}
}
}
}

void speedTest(boolean targetDirection)
{
if(newStep)
{
if(motor.targetReached)
{
delay(timeFactor * 5000);
testGeschwindigkeit++;
if(testGeschwindigkeit >= 30)
{
newStep = false;
}
motor.Set(testGeschwindigkeit, targetDirection);
Serial.print(„Geschwindigkeit: „);
Serial.println(testGeschwindigkeit);
}
}
else
{
if(motor.targetReached)
{
delay(timeFactor * 5000);
testGeschwindigkeit–;
motor.Set(testGeschwindigkeit, targetDirection);
if(testGeschwindigkeit <= 0)
{
ablaufSchritt++;
newStep = true;
}
Serial.print(„Geschwindigkeit: „);
Serial.println(testGeschwindigkeit);
}
}
}

/*/////////////////////////////////////////////////////////////////////////////////////////////////////*//*/////////////////////////////////////////////////////////////////////////////////////////////////////*/
/*******************************************************************************
* ABLAUF (Hier kann man so viel definierne wie man möchte) *
*******************************************************************************/

/*******************************************************************************
*
*
* Man kann hier die folgenden Funktionen benutzen:
*
*
* //////////////////////////////////////////////////////////////////////////////
* Alles was mit dem Motor zu tun hat
* //////////////////////////////////////////////////////////////////////////////
*
* geschwindigkeit(zielgeschwindigkeit, richtung);
* zielgeschwindigkeit (0-255) wobei 0 stop und 255 vollgas sinde
* richtung: links / rechts
* z.B. geschwindigkeit(112, links);
* geschwindigkeit(0); heisst bremsen
*
* drehen(zielgeschwindigkeit, richtung, minimaleumdrehungen, endposition, korrekturwert);
* zielgeschwindigkeit (0-255) wobei 0 stop und 255 vollgas sinde
* richtung: links / rechts
* minimalumdrehungen: anzahl ganzer umdrehunen bevor zielstop angefahren wird. z.B. 0, 1, 2 usw.
* endposition: 12, 3, 6, 9
* korrekturwert: Dauer in Millisekunden in welcher zurückkorrigiert wird.
* -> wenn das bild auf 12 uhr ist und mit geschwindigkeit 120, 2 1/2 umdrehungen CW auf 6 uhr soll: drehen(120, rechts, 2, 6)
* -> wenn es das selbe aber nur 1 1/2 umdrehungen machen sollte: drehen(120, rechts, 1, 6)
* -> nachmals das selbe aber direkt von 12 auf 6 Uhr: drehen(120, rechts, 0, 6)
* -> von 12 auf 12 eine umdrehung CCW: drehen(120, links, 1, 12)
* -> von 12 auf 12 eine umdrehung CCW mit dem bedarf 100 mS zurück zu korrigieren: drehen(120, links, 1, 12, 100)
*
* zuSensor(endposition, richtung, korrekturwert);
* endposition: 12, 3, 6, 9
* richtung: links / rechts
* korrekturwert: Dauer in Millisekunden in welcher zurückkorrigiert wird.
* -> das bild dreht sich in der gewünschten richtung langsam zur endposition
*
*
* //////////////////////////////////////////////////////////////////////////////
* Alles was mit Beleuchtung zu tun hat
* //////////////////////////////////////////////////////////////////////////////
*
* ledStrip(modus);
* modus: ein / aus / strobo
* springt nicht automatisch weiter
*
* licht(modus);
* modus: ein / aus
* springt nicht automatisch weiter
*
*
* //////////////////////////////////////////////////////////////////////////////
* Alles was mit dem Ablauf zu tun hat
* //////////////////////////////////////////////////////////////////////////////
*
* warte(sekunden);
* sekunden als Ganzzahl
*
* springeZumAnfang();
* springt zu case 1
*
* springeWeiter();
* springt zum nächsten punkt z.B. von case 22 zu case 23
*
* springeZuSchritt(Schritt);
* springt zum gewünschten Schritt: springeZuSchritt(5) -> springt zu case 5
*
*
* //////////////////////////////////////////////////////////////////////////////
* Andere Sachen
* //////////////////////////////////////////////////////////////////////////////
*
* glocke(anzahl);
* läutet die glocke und sprint einen schritt weitter
*
* voice();
* spielt das voice modul ab
*
*
*******************************************************************************/

void ablauf()
{
switch(ablaufSchritt)
{
case 0:
zuSensor(12, rechts, 500); //***justieren*** 12h korrekt
break;

/*/////////////////////////////////////////////////////////////////////////////////////////////////////*/
//TEASER
//1.1
case 1:
licht(ein);
warte(3);
break; // break, muss immer hier sein
//1.2
case 2:
analogWrite(pinPwm, absolutMinGeschwindigkeit);
digitalWrite(pinDir, links);
delay(timeFactor * 500); // der Wert bestimmt wie weit es geht = ***Pos 11h – korrekt
analogWrite(pinPwm, 0);
springeWeiter();
break;

//1.3
case 3:
warte(30); //***vor Ort bestimmen***
break;

//1.4
case 4:
analogWrite(pinPwm, absolutMinGeschwindigkeit);
digitalWrite(pinDir, rechts);
delay(timeFactor * 990); // der Wert bestimmt wie weit es geht = ***Pos 1h – korrekt
analogWrite(pinPwm, 0);
springeWeiter();
break;

//1.5
case 5:
warte(30); //***vor Ort bestimmen***
break;

//1.6
case 6:
zuSensor(12, links, 190);//***korrekt auf Sensor 12h ***Justieren
break;

//1.7
case 7:
warte(40); //***Bestimmen vor Ort***
//springeZuSchritt(31); //*** korrekt
springeZumAnfang();
break;
/*///////////////////////////////Ende Intro////////////////////////////////////////////////////////*/

//1.8
case 8:
analogWrite(pinPwm, absolutMinGeschwindigkeit);
digitalWrite(pinDir, rechts);
delay(timeFactor * 2100); // der Wert bestimmt wie weit es geht.
analogWrite(pinPwm, 0);
springeWeiter();
break;

//1.9
case 9:
warte(5);
break;

//1.10
case 10:
zuSensor(6, links, 100); //ok
break;

//1.11
case 11:
warte(5);
break;

//1.12
case 12:
zuSensor(3, rechts, 100); // ok
break;

//1.13
case 13:
warte(5);
break;

//1.14
case 14:
zuSensor(12, links, 100); //*** ok
break;

//1.15test
case 15:
glocke(1);
break;

//1.15test
case 16:
//springeZumAnfang();
springeZuSchritt(31); //***Ende Intro – ok korrekt ausgeführt
//warte(5);
break;

/*/////////////////////////wenn Sensor_aktiv////////////////////////////////////////////////////////////////*/
//SPIEL
//2.1
case 31:
licht(aus);
delay(500 * timeFactor);
licht(ein);
delay(200 * timeFactor);
licht(aus);
delay(500 * timeFactor);
licht(ein);
delay(200 * timeFactor);
licht(aus);
delay(500 * timeFactor);
licht(ein);
delay(200 * timeFactor);
licht(aus);
delay(500 * timeFactor);
licht(ein);
delay(1000 * timeFactor);
warte(1); // zu Beginn SPIEL 2s
break;

//2.2
case 32:
drehen(21, links, 3, 3, 950); //*** 3 Umdrehungen***
break;

//2.3
case 33:
warte(3);
break;

//2.4
case 34:
drehen(30, rechts, 1, 3, 400); //*** korrekt geht auf Sensor 3h – ok
break;

//2.5
case 35:
warte(1);
break;

//2.6
case 36:
//drehen(absolutMinGeschwindigkeit, links, 1, 6, 100);
drehen(44, links, 1, 6, 100); //*** geht auf Sensor 12h!!! aber ok so lassen
break;

//2.7
case 37:
warte(1);
break;

//2.8
case 38:
//drehen(100, rechts, 4, 6, 100);
springeZuSchritt(40); //***ok so lassen
break;

//2.9
case 39:
warte(1);
break;

//2.10
case 40:
drehen(25, links, 3, 6, 490); //***Wichtig, muss waagrecht sein
break;

//2.11
case 41:
warte(3);
//springeZumAnfang();
springeZuSchritt(51);
break;

/*/////////////////////////////////////////////////////////////////////////////////////////////////////*/
//FINALE

//3.1
case 51:
glocke(2);
break;

//3.2
case 52:
warte(2);
break;

//3.3
case 53:
licht(aus);
warte(1);
break;

//3.4
case 54:
ledStrip(ein);
warte(2);
break;

//3.5
case 55:
geschwindigkeit(200, rechts); //*** Strobo setzt relativ spät ein = ist def Wert
break;

//3.6
case 56:
ledStrip(strobo);
geschwindigkeit(250, rechts); //*** max 255 – 250 = ist def Wert
break;

//3.7
case 57:
warte(3);
break;

//3.8
case 58:
geschwindigkeit(100, rechts); //*** Strobo läuft lange mit auslaufender Geschwindigkeit mit = ist def Wert
break;

//3.9
case 59:
ledStrip(ein);
geschwindigkeit(absolutMinGeschwindigkeit, rechts);
break;

//3.10
case 60:
zuSensor(12, rechts, 600); //***justieren***
break;

//3.11
case 61:
warte(2);
break;

//3.12
case 62:
ledStrip(aus);
warte(1);
break;

//3.13
case 63:
licht(ein);
warte(0); // 0s warten vor GameOver
break;

//3.14
case 64:
voice();
break;

//3.15
case 65:
warte(5); //***???
break;

//3.16
case 66:
springeZumAnfang();
break;

///////////////////////////////////////////////////
// ausschalten
case 81:
glocke(1);
break;

case 82:
geschwindigkeit(0);
break;

case 83:
warte(5);

case 84:
licht(ein);
ledStrip(aus);
glocke(5);
break;

case 85:
// warten bis die installation ausgeschaltet wird.
break;

case 100:
betrachter();
break;

default:
springeZumAnfang(); // dies sollte immer so bleiben
break;
}
}

//***************************************************
zurück zu BILD>