// the compiler switch for an ESP8266 is looking like this: #elif defined(ARDUINO_ARCH_ESP8266) #include "CodeRacer.h" //Konstruktor ohne Pins ... alle Vorgaben kommen aus dem CodeRacer.h Header file CodeRacer::CodeRacer() { _taster_pin = H_TASTERPIN; _servopin = H_SERVOPIN; _us_trigger_pin = H_US_TRIG; _us_echo_pin = H_US_ECHO; _motor_links_frwd_pin = H_MOTORLI_FWRD; _motor_links_back_pin = H_MOTORLI_BACK; _motor_links_enable_pin = H_MOTORLI_SPEED; _motor_rechts_frwd_pin = H_MOTORRE_FWRD; _motor_rechts_back_pin = H_MOTORRE_BACK; _motor_rechts_enable_pin = H_MOTORRE_SPEED; _led_frwd_pin = H_LED_VORWAERTS; _led_stop_pin = H_LED_STOP; _led_links_pin = H_LED_LINKS; _led_rechts_pin = H_LED_RECHTS; _servo_dummy = new Servo(); _servo = new Servo(); _servo_mitte = H_SERVO_MITTE; _servo_links = H_SERVO_LINKS; _servo_rechts = H_SERVO_RECHTS; _schwenk_links = H_SERVO_SCHWENK_LINKS; _schwenk_rechts = H_SERVO_SCHWENK_RECHTS; _schwenk_position = _servo_mitte; _schwenk_richtung = SERVO_SCHWENK_LI; _schwenk_millis = millis(); _motor_links_tempo = H_MOTORLI_TEMPO; _motor_rechts_tempo = H_MOTORRE_TEMPO; _drehung_links_ms = H_RACER_LINKS_MS; _drehung_rechts_ms = H_RACER_RECHTS_MS; coderracer_activ = false; _coderracer_activ = true; } // Konstruktor mit pin Übergaben ... CodeRacer::CodeRacer(int tasterpin , int servopin, int us_trigger_pin, int us_echo_pin, int motor_links_frwd_pin, int motor_links_back_pin, int motor_links_enable_pin, int motor_rechts_frwd_pin, int motor_rechts_back_pin, int motor_rechts_enable_pin, int led_frwd, int led_stop, int led_links, int led_rechts ) { _taster_pin = tasterpin; _servopin = servopin; _us_trigger_pin = us_trigger_pin; _us_echo_pin = us_echo_pin; _motor_links_frwd_pin = motor_links_frwd_pin; _motor_links_back_pin = motor_links_back_pin; _motor_links_enable_pin = motor_links_enable_pin; _motor_rechts_frwd_pin = motor_rechts_frwd_pin; _motor_rechts_back_pin = motor_rechts_back_pin; _motor_rechts_enable_pin = motor_rechts_enable_pin; _led_frwd_pin = led_frwd; _led_stop_pin = led_stop; _led_links_pin = led_links; _led_rechts_pin = led_rechts; _servo_dummy = new Servo(); _servo = new Servo(); _servo_mitte = H_SERVO_MITTE; _servo_links = H_SERVO_LINKS; _servo_rechts = H_SERVO_RECHTS; _schwenk_links = H_SERVO_SCHWENK_LINKS; _schwenk_rechts = H_SERVO_SCHWENK_RECHTS; _schwenk_position = _servo_mitte; _schwenk_richtung = SERVO_SCHWENK_LI; _schwenk_millis = millis(); _motor_links_tempo = H_MOTORLI_TEMPO; _motor_rechts_tempo = H_MOTORRE_TEMPO; _drehung_links_ms = H_RACER_LINKS_MS; _drehung_rechts_ms = H_RACER_RECHTS_MS; coderracer_activ = false; _coderracer_activ = true; _drive_forward = false; } void CodeRacer::begin() { // Ultraschallsensor pinMode(_us_trigger_pin, OUTPUT); // Ultraschallsensor: TRIG ist ein Ausgangspin. Es wird ein Signal zum Ultraschallsensor gesendet pinMode(_us_echo_pin, INPUT); // Ultraschallsensor: ECHO ist ein Eingangspin. Es wird ein Signal vom Ultraschallsensor empfangen // Servo _servo->attach(_servopin); // dem Servo Objekt "sagen" an welchen Pin am Schaltkreis der Server angeschlossen ist // Linker Motor pinMode(_motor_links_frwd_pin, OUTPUT); // Linker Motor FORWARD ist ein Ausgang. pinMode(_motor_links_back_pin, OUTPUT); // Linker Motor BACKWARD ist ein Ausgang. ledcSetup(MOTORPWM_LINKS, 5000, 8); // channel 1, 50 Hz, 8-bit width ledcAttachPin(_motor_links_enable_pin, MOTORPWM_LINKS); // Linker Motor SPEED mit Kanal 1 verbunden analog_write(_motor_links_enable_pin, 0); // Linken Motor sicherheitshalber ausschalten :-) // Rechter Motor pinMode(_motor_rechts_frwd_pin, OUTPUT); // Rechter Motor FORWARD ist ein Ausgang. pinMode(_motor_rechts_back_pin, OUTPUT); // Rechter Motor BACKWARD ist ein Ausgang. ledcSetup(MOTORPWM_RECHTS, 5000, 8); // channel 2, 50 Hz, 8-bit width ledcAttachPin(_motor_rechts_enable_pin, MOTORPWM_RECHTS); // Rechter Motor SPEED mit Kanal 2 verbunden analog_write(_motor_rechts_enable_pin, 0); // Rechten Motor sicherheitshalber ausschalten :-) // LEDs pinMode(_led_frwd_pin, OUTPUT); // LED Vorwärts ist ein Ausgang pinMode(_led_stop_pin, OUTPUT); // LED Stop ist ein Ausgang pinMode(_led_links_pin, OUTPUT); // LED Links ist ein Ausgang pinMode(_led_rechts_pin, OUTPUT); // LED Rechts ist ein Ausgang // alle LEDS aus digitalWrite(_led_frwd_pin, LOW); digitalWrite(_led_stop_pin, LOW); digitalWrite(_led_links_pin, LOW); digitalWrite(_led_rechts_pin, LOW); // Taster taster_last_pressed_ms = 0; pinMode(_taster_pin, INPUT_PULLUP); attachInterrupt(digitalPinToInterrupt(_taster_pin), set_taster_state, FALLING); Serial.println("CodeRacer initialisiert ... "); } void CodeRacer::servo_einstellungen(int winkel_mitte, int winkel_links, int winkel_rechts, int schwenk_links, int schwenk_rechts) { _servo_mitte = winkel_mitte; _servo_links = winkel_links; _servo_rechts = winkel_rechts; _schwenk_links = schwenk_links; _schwenk_rechts = schwenk_rechts; _schwenk_position = _servo_mitte; _schwenk_richtung = SERVO_SCHWENK_LI; _schwenk_millis = millis(); Serial.println("CodeRacer Servo eingestellt ... "); } void CodeRacer::motor_einstellungen(int motor_links_tempo, int motor_rechts_tempo, int drehung_links_ms, int drehung_rechts_ms) { _motor_links_tempo = motor_links_tempo; _motor_rechts_tempo = motor_rechts_tempo; _drehung_links_ms = drehung_links_ms; _drehung_rechts_ms = drehung_rechts_ms; } void CodeRacer::analog_write(int pin, int speed) { if (pin == _motor_links_enable_pin) { ledcWrite(MOTORPWM_LINKS, speed); } if (pin == _motor_rechts_enable_pin) { ledcWrite(MOTORPWM_RECHTS, speed); } } void CodeRacer::anhalten() { Serial.println("RACER_ANHALTEN"); // Meldung am Monitor ausgeben _drive_forward = false; //Rechten Motor abschalten digitalWrite(_motor_rechts_frwd_pin, LOW); digitalWrite(_motor_rechts_back_pin, LOW); // Linken Motor abschalten digitalWrite(_motor_links_frwd_pin, LOW); digitalWrite(_motor_links_back_pin, LOW); // Motoren beide ausschalten analog_write(_motor_rechts_enable_pin, 0); analog_write(_motor_links_enable_pin, 0); // LEDs setzen digitalWrite(_led_frwd_pin, LOW); digitalWrite(_led_stop_pin, HIGH); digitalWrite(_led_links_pin, LOW); digitalWrite(_led_rechts_pin, LOW); delay(1000); } void CodeRacer::normal_tempo() { //Serial.println("RACER_NORMAL_TEMPO"); // Meldung am Monitor ausgeben analog_write(_motor_rechts_enable_pin, _motor_rechts_tempo); analog_write(_motor_links_enable_pin, _motor_links_tempo); _drive_forward = true; _drive_normal_forward = true; } void CodeRacer::vorwaerts() { Serial.println("RACER_VORWAERTS"); // Meldung am Monitor ausgeben if (false == _drive_forward) { // Rechten Motor auf vorwärts stellen digitalWrite(_motor_rechts_frwd_pin, HIGH); digitalWrite(_motor_rechts_back_pin, LOW); // Linken Motor auf vorwärts stellen digitalWrite(_motor_links_frwd_pin, HIGH); digitalWrite(_motor_links_back_pin, LOW); // Motoren beide anschalten analog_write(_motor_rechts_enable_pin, MOTORRE_MAX_TEMPO); analog_write(_motor_links_enable_pin, MOTORLI_MAX_TEMPO); // LEDs setzen digitalWrite(_led_frwd_pin, HIGH); digitalWrite(_led_stop_pin, LOW); digitalWrite(_led_links_pin, LOW); digitalWrite(_led_rechts_pin, LOW); _drive_forward = true; _drive_normal_forward = false; _drive_forward_ms = millis(); } else { if (false == _drive_normal_forward) { if ((millis() - _drive_forward_ms) > MOTOR_MAX_SPEED_START_MS) { normal_tempo(); } } } } void CodeRacer::links() { Serial.println("RACER_LINKS"); // Meldung am Monitor ausgeben _drive_forward = false; // LEDs setzen digitalWrite(_led_frwd_pin, LOW); digitalWrite(_led_stop_pin, LOW); digitalWrite(_led_links_pin, HIGH); digitalWrite(_led_rechts_pin, LOW); // Rechten Motor auf vorwärts stellen digitalWrite(_motor_rechts_frwd_pin, HIGH); digitalWrite(_motor_rechts_back_pin, LOW); // Linken Motor auf rückwärts stellen digitalWrite(_motor_links_frwd_pin, LOW); digitalWrite(_motor_links_back_pin, HIGH); // Motoren beide anschalten analog_write(_motor_rechts_enable_pin, MOTORRE_MAX_TEMPO); analog_write(_motor_links_enable_pin, MOTORLI_MAX_TEMPO); // Warten bis der RAcer sich gedreht hat delay(_drehung_links_ms); // Motoren wieder auschalten analog_write(_motor_rechts_enable_pin, 0); analog_write(_motor_links_enable_pin, 0); } void CodeRacer::rechts() { Serial.println("RACER_RECHTS"); // Meldung am Monitor ausgeben _drive_forward = false; // LEDs setzen digitalWrite(_led_frwd_pin, LOW); digitalWrite(_led_stop_pin, LOW); digitalWrite(_led_links_pin, LOW); digitalWrite(_led_rechts_pin, HIGH); // Rechten Motor auf rückwärts stellen digitalWrite(_motor_rechts_frwd_pin, LOW); digitalWrite(_motor_rechts_back_pin, HIGH); // Linken Motor auf vorwärts stellen digitalWrite(_motor_links_frwd_pin, HIGH); digitalWrite(_motor_links_back_pin, LOW); // Motoren beide anschalten analog_write(_motor_rechts_enable_pin, MOTORRE_MAX_TEMPO); analog_write(_motor_links_enable_pin, MOTORLI_MAX_TEMPO); // Warten bis der RAcer sich gedreht hat delay(_drehung_rechts_ms); // Motoren wieder auschalten analog_write(_motor_rechts_enable_pin, 0); analog_write(_motor_links_enable_pin, 0); } void CodeRacer::servo_rechts() { Serial.println("SERVO_RECHTS"); // Meldung am Monitor ausgeben _servo->write(_servo_rechts); // Servo auf den Winkel rechts drehen delay(1000); // Kurz warten, dass der Servo die Stellung erreicht } void CodeRacer::servo_links() { Serial.println("SERVO_LINKS"); // Meldung am Monitor ausgeben _servo->write(_servo_links); // Servo auf den Winkel links drehen delay(1000); // Kurz warten, dass der Servo die Stellung erreicht } void CodeRacer::servo_mitte() { Serial.println("SERVO_MITTE"); // Meldung am Monitor ausgeben _servo->write(_servo_mitte); // Servo auf den Winkel links drehen _schwenk_position = _servo_mitte; // Servo schaut direkt nach vorn _schwenk_millis = millis(); delay(1000); // Kurz warten, dass der Servo die Stellung erreicht } void CodeRacer::servo_schwenk() { if (millis() - _schwenk_millis > SERVO_SCHWENK_MS) { _schwenk_position = _schwenk_position + _schwenk_richtung; if (_schwenk_position >= _schwenk_links) { _schwenk_position = _schwenk_links; _schwenk_richtung = SERVO_SCHWENK_RE; } if (_schwenk_position <= _schwenk_rechts) { _schwenk_position = _schwenk_rechts; _schwenk_richtung = SERVO_SCHWENK_LI; } _servo->write(_schwenk_position); // Servo auf den Winkel links drehen _schwenk_millis = millis(); } } long CodeRacer::abstand_messen() { long abstand_cm; long single_echo_dauer_us; long long echo_dauer_us; int messnr = 0; echo_dauer_us = 0; do{ // Messung starten - ein kurzer Pulse "HIGH" wird zum TRIG pin des Ultraschallsensors geschickt pinMode(_us_echo_pin, OUTPUT); pinMode(_us_echo_pin, INPUT); digitalWrite(_us_trigger_pin, LOW); delayMicroseconds(2); digitalWrite(_us_trigger_pin, HIGH); delayMicroseconds(10); digitalWrite(_us_trigger_pin, LOW); // Messung der Dauer in Mikrosekundenmeasure bis das ECHO Pin vom Ultraschallsensor HIGH wird single_echo_dauer_us = pulseIn(_us_echo_pin, HIGH, US_MAX_ECHO_TIME_US); if (single_echo_dauer_us == 0) { echo_dauer_us = echo_dauer_us + US_MAX_ECHO_TIME_US; messnr++; } else { if (single_echo_dauer_us > 200) { echo_dauer_us = echo_dauer_us + single_echo_dauer_us; messnr++; } } } while (messnr < 1); //echo_dauer_us = echo_dauer_us >> 4; // convert into cm ... 344m/sec is the speed of noise - thus 34400cm/sec ... or 34,400cm/milisec ... or 0,0344cm/microsec // the echo has to go the distance twice - forth and back - so the duration has to be the half of the measured one // distance_cm = echo_duration/2 * 0,0344 or distance_cm = echo_duration/2 / 29,1 or distance_cm = echo_duration * 0,0172 // distance_cm = (echo_duration/2) / 29.1; abstand_cm = echo_dauer_us * 0.0172; //Messwert am Monitor anzeigen Serial.print("ABSTAND_MESSEN. Der Abstand in cm ist (mindestens):"); Serial.println(abstand_cm); return(abstand_cm); } bool CodeRacer::start_stop() { if (_coderracer_activ != coderracer_activ) { _coderracer_activ = coderracer_activ; if (true == _coderracer_activ) { digitalWrite(_led_stop_pin, LOW); } else { anhalten(); servo_mitte(); digitalWrite(_led_stop_pin, HIGH); } } return(_coderracer_activ); } void IRAM_ATTR CodeRacer::set_taster_state() { if ((millis() - taster_last_pressed_ms) > 200) { taster_last_pressed_ms = millis(); if (false == coderracer_activ) { coderracer_activ = true; } else { coderracer_activ = false; } } }