CodeRacer.cpp

// the compiler switch for an ESP8266 is looking like this: #elif defined(ARDUINO_ARCH_ESP8266)
#include "CodeRacer.h"

CodeRacer::CodeRacer()
{
    _button_pin = H_BUTTON_PIN;
    _servo_pin = H_SERVO_PIN;
    _us_trigger_pin = H_US_TRIG_PIN;
    _us_echo_pin = H_US_ECHO_PIN;
    _drive_left_frwd_pin = H_DRIVE_LEFT_FWRD_PIN;
    _drive_left_back_pin = H_DRIVE_LEFT_BACK_PIN;
    _drive_left_enable_pin = H_DRIVE_LEFT_ENABLE_PIN;
    _drive_right_frwd_pin = H_DRIVE_RIGHT_FWRD_PIN;
    _drive_right_back_pin = H_DRIVE_RIGHT_BACK_PIN;
    _drive_right_enable_pin = H_DRIVE_RIGHT_ENABLE_PIN;
    _led_frwd_pin = H_LED_FRWD_PIN;
    _led_stop_pin = H_LED_STOP_PIN;
    _led_left_pin = H_LED_LEFT_PIN;
    _led_right_pin = H_LED_RIGHT_PIN;
}

CodeRacer::CodeRacer(uint8_t button_pin , uint8_t   servo_pin,
    uint8_t us_trigger_pin, uint8_t us_echo_pin,
    uint8_t drive_left_frwd_pin, uint8_t drive_left_back_pin, uint8_t drive_left_enable_pin,
    uint8_t drive_right_frwd_pin, uint8_t drive_right_back_pin, uint8_t drive_right_enable_pin,
    uint8_t led_frwd_pin, uint8_t led_stop_pin, uint8_t led_left_pin, uint8_t led_right_pin
)
{
    _button_pin = button_pin;
    _servo_pin = servo_pin;
    _us_trigger_pin = us_trigger_pin;
    _us_echo_pin = us_echo_pin;
    _drive_left_frwd_pin = drive_left_frwd_pin;
    _drive_left_back_pin = drive_left_back_pin;
    _drive_left_enable_pin = drive_left_enable_pin;
    _drive_right_frwd_pin = drive_right_frwd_pin;
    _drive_right_back_pin = drive_right_back_pin;
    _drive_right_enable_pin = drive_right_enable_pin;
    _led_frwd_pin = led_frwd_pin;
    _led_stop_pin = led_stop_pin;
    _led_left_pin = led_left_pin;
    _led_right_pin = led_right_pin;
}

void CodeRacer::begin() {

    // init of variables and objects

    _servo_dummy = new Servo();     // the dummy is needed so far to avoid conflicts with analog write
    _servo = new Servo();
    servo_center_pos = H_SERVO_CENTER_POS;
    servo_left_pos = H_SERVO_LEFT_POS;
    servo_right_pos = H_SERVO_RIGHT_POS;
    servo_sweep_left_pos = H_SERVO_SWEEP_LEFT_POS;
    servo_sweep_right_pos = H_SERVO_SWEEP_RIGHT_POS;
    _servo_position = servo_center_pos;
    _servo_sweep_step = SERVO_SWEEP_TO_LEFT_STEP;
    _servo_position_set_at_ms = millis();
    _servo_position_eta_in_ms = 0;

    _drive_left_speed = H_DRIVE_LEFT_SPEED;
    _drive_right_speed = H_DRIVE_RIGHT_SPEED;

    _turn_left_for_ms = H_RACER_TURN_LEFT_FOR_MS;
    _turn_right_for_ms = H_RACER_TURN_RIGHT_FOR_MS;

    coderracer_activ = false;
    _coderracer_activ = true;
    _drive = false;
    _drive_set_at_ms = millis();
    _servo_sweep = false;

    _last_led_switched_at_ms = millis();
    _last_led_on = 0;
    _led_count = 3;

    _servo_look_around_at_ms = millis() + random(FUN_MIN_PAUSE_MS, FUN_MAX_PAUSE_MS);

    _usonic_stop_distance_cm = H_US_STOP_DISTANCE_CM;
    usonic_set_stop_distance_cm(_usonic_stop_distance_cm);
    _coderacer_stopped_at_min_distance = false;

    // Ultrasonic sensor
    pinMode(_us_trigger_pin, OUTPUT);
    pinMode(_us_echo_pin, INPUT);
    
    // Servo drive
    _servo->attach(_servo_pin);

    // Left drive
    pinMode(_drive_left_frwd_pin, OUTPUT);
    pinMode(_drive_left_back_pin, OUTPUT);
    set_drive_left_state(DRIVESTOP);
    ledcSetup(DRIVE_PWM_LEFT_CHANNEL, 5000, 8);                                                 // channel , 50 Hz, 8-bit width
    ledcAttachPin(_drive_left_enable_pin, DRIVE_PWM_LEFT_CHANNEL);          // connect left drive enable with PWM channel

    // Right drive
    pinMode(_drive_right_frwd_pin, OUTPUT);
    pinMode(_drive_right_back_pin, OUTPUT);
    set_drive_right_state(DRIVESTOP);
    ledcSetup(DRIVE_PWM_RIGHT_CHANNEL, 5000, 8);                                                // channel , 50 Hz, 8-bit width
    ledcAttachPin(_drive_right_enable_pin, DRIVE_PWM_RIGHT_CHANNEL);        // connect right drive enable pin with PWM channel

    // LEDs
    pinMode(_led_frwd_pin, OUTPUT);
    pinMode(_led_stop_pin, OUTPUT);
    pinMode(_led_left_pin, OUTPUT);
    pinMode(_led_right_pin, OUTPUT);
    // all LEDS off
    set_leds_all_off();

    // Button & -interrupt
    button_last_pressed_at_ms = 0;
    pinMode(_button_pin, INPUT_PULLUP);
    attachInterrupt(digitalPinToInterrupt(_button_pin), _set_button_state, FALLING);

    // Random
    randomSeed(analogRead(0));

    //fun stuff
    coderacer_fun_enabled = false;

}

//**************************************
//*** Coderacer hihger level methods ***
//**************************************
void CodeRacer::stop_driving() {
    _servo_sweep = false;
    _drive = false;
    set_drives_stop_left_right();
    set_leds_left_stop_frwd_right(LEDOFF, LEDON, LEDOFF, LEDOFF);
}

void CodeRacer::drive_forward()
{
    drive_forward(_drive_left_speed, _drive_right_speed);
}

void CodeRacer::drive_forward(uint8_t left_speed, uint8_t right_speed)
{
    set_drives_states_left_right(DRIVEFRWD, DRIVEFRWD);
    set_drives_speed_left_right(left_speed, right_speed);
    set_leds_left_stop_frwd_right(LEDOFF, LEDOFF, LEDON, LEDOFF);
    _drive = true;
    _drive_set_at_ms = millis();
}

void CodeRacer::drive_backward()
{
    drive_backward(_drive_left_speed, _drive_right_speed);
}

void CodeRacer::drive_backward(uint8_t left_speed, uint8_t right_speed)
{
    set_drives_states_left_right(DRIVEBACK, DRIVEBACK);
    set_drives_speed_left_right(left_speed, right_speed);
    set_leds_left_stop_frwd_right(LEDOFF, LEDON, LEDON, LEDOFF);
    _drive = true;
    _drive_set_at_ms = millis();
}

void CodeRacer::turn_left()
{
    turn_left(_turn_left_for_ms, _drive_left_speed, _drive_right_speed);
}

void CodeRacer::turn_left(unsigned long turn_for_ms)
{
    turn_left(turn_for_ms, _drive_left_speed, _drive_right_speed);
}

void CodeRacer::turn_left(unsigned long turn_for_ms, uint8_t left_speed, uint8_t right_speed)
{
    _drive = false;
    set_leds_left_stop_frwd_right(LEDON, LEDOFF, LEDOFF, LEDOFF);   // LEDs setzen
    set_drives_states_left_right(DRIVEBACK, DRIVEFRWD);
    set_drives_speed_left_right(left_speed, right_speed);
    // wait set delay for the timed turn
    _turn_left_for_ms = turn_for_ms;
    delay(_turn_left_for_ms);
    // stop drives again
    set_drives_stop_left_right();
}

void CodeRacer::turn_right()
{
    turn_right(_turn_right_for_ms, _drive_left_speed, _drive_right_speed);
}

void CodeRacer::turn_right(unsigned long turn_for_ms)
{
    turn_right(turn_for_ms, _drive_left_speed, _drive_right_speed);
}

void CodeRacer::turn_right(unsigned long turn_for_ms, uint8_t left_speed, uint8_t right_speed)
{
    _drive = false;
    set_leds_left_stop_frwd_right(LEDOFF, LEDOFF, LEDOFF, LEDON);       // LEDs setzen
    set_drives_states_left_right(DRIVEFRWD, DRIVEBACK);
    set_drives_speed_left_right(left_speed, right_speed);
    // wait set delay for the timed turn
    _turn_right_for_ms = turn_for_ms;
    delay(_turn_right_for_ms);
    // stop drives again
    set_drives_stop_left_right();
}

void CodeRacer::start_stop_at_min_distance() {
    start_stop_at_min_distance(_usonic_stop_distance_cm);
}

void CodeRacer::start_stop_at_min_distance(unsigned long min_distance_cm) {
    if (false == _coderacer_stop_at_distance_enabled) {
        _coderacer_stopped_at_min_distance = false;
        usonic_set_stop_distance_cm(min_distance_cm);
        _coderacer_stop_at_distance_enabled = true;
    }
}

void CodeRacer::stop_stop_at_min_distance() {
    _coderacer_stop_at_distance_enabled = false;
}

bool CodeRacer::start_stop() {
    if (_coderracer_activ != coderracer_activ) {
        _coderracer_activ = coderracer_activ;
        if (true == _coderracer_activ) {
            set_leds_all_off();
            delay(500);
        }
        else {
            stop_driving();
            set_leds_all_on();
            delay(200);
            servo_set_to_center();
            _servo_look_around_at_ms = millis() + random(20000, 120000);
        }
    }

    if ((false == _coderracer_activ) && (true == coderacer_fun_enabled)) {
        kitt();
        look_around();
    }
        
    return(_coderracer_activ);
}
 // end of group higherlevelmeths
bool CodeRacer::stopped_at_min_distance() {
    return(_coderacer_stopped_at_min_distance);
}

bool CodeRacer::is_driving() {
    return(_drive);
}

unsigned long CodeRacer::turn_left_for_ms() {
    return(_turn_left_for_ms);
}

unsigned long CodeRacer::turn_right_for_ms() {
    return(_turn_right_for_ms);
}

void CodeRacer::set_inactive() {
    coderracer_activ = false;
}

void CodeRacer::set_active() {
    coderracer_activ = true;
}

bool CodeRacer::is_active() {
    return(coderracer_activ);
}
 // end of group higherlevelgetters // end of group higherlevel

//**************************************
//*** Just for fun                                   ***
//**************************************
void CodeRacer::look_around()
{
    if (_servo_look_around_at_ms < millis()) {
        _servo_look_around_at_ms = millis() + random(FUN_MIN_PAUSE_MS, FUN_MAX_PAUSE_MS);
        servo_set_to_left();
        delay(500);
        servo_set_to_right();
        delay(800);
        servo_set_to_center();
        delay(300);
        servo_set_to_left();
        delay(100);
        servo_set_to_center();
    }
}

void CodeRacer::kitt()
{
    if (millis() - _last_led_switched_at_ms > LED_SWITCH_MS) {
        _last_led_switched_at_ms = millis();
        if (_last_led_on >= 5) {
            _led_count = -1;
        }
        else if (_last_led_on <= 0) {
            _led_count = 1;
        }
        _last_led_on = _last_led_on + _led_count;
        switch (_last_led_on) {
        case 0:
            set_leds_left_stop_frwd_right(LEDON, LEDOFF, LEDOFF, LEDOFF);
            break;
        case 1:
            set_leds_left_stop_frwd_right(LEDON, LEDOFF, LEDOFF, LEDOFF);
            break;
        case 2:
            set_leds_left_stop_frwd_right(LEDOFF, LEDON, LEDOFF, LEDOFF);
            break;
        case 3:
            set_leds_left_stop_frwd_right(LEDOFF, LEDOFF, LEDON, LEDOFF);
            break;
        case 4:
        case 5:
            set_leds_left_stop_frwd_right(LEDOFF, LEDOFF, LEDOFF, LEDON);
            break;
        }
    }
}
 // end of group lowerlevelfun

//**************************************
//*** Servo drive lower level control ***
//**************************************
void CodeRacer::servo_settings(uint8_t pos_center, uint8_t pos_left, uint8_t pos_right, uint8_t sweep_left_pos, uint8_t sweep_right_pos)
{
    servo_center_pos = pos_center;
    servo_left_pos = pos_left;
    servo_right_pos = pos_right;
    servo_sweep_left_pos = sweep_left_pos;
    servo_sweep_right_pos = sweep_right_pos;
}

void CodeRacer::servo_sweep()
{
    uint8_t position;
    _servo_sweep = true;
    if (millis() - _servo_position_set_at_ms > SERVO_SWEEP_MS) {
        position = _servo_position + _servo_sweep_step;
        //sprintf(_debugmsg,"[%s] current position=%ld newpostion=%ld", __func__, _servo_position, position);
        if ((position >= servo_sweep_left_pos) || (position >= SERVO_MAX_POSITION)) {
            position = servo_sweep_left_pos;
            _servo_sweep_step = SERVO_SWEEP_TO_RIGHT_STEP;
        }
        if ((position <= servo_sweep_right_pos) || (position <= SERVO_MIN_POSITION)) {
            position = servo_sweep_right_pos;
            _servo_sweep_step = SERVO_SWEEP_TO_LEFT_STEP;
        }
        _servo_set_position(position);
    }
}

void CodeRacer::servo_set_to_right()
{
    servo_set_position_wait(servo_right_pos);
}

void CodeRacer::servo_set_to_left()
{
    servo_set_position_wait(servo_left_pos);
}

void CodeRacer::servo_set_to_center()
{
    servo_set_position_wait(servo_center_pos);
}

uint8_t CodeRacer::servo_set_position_wait(uint8_t position)
{
    _servo_sweep = false;
    unsigned long wait_time_ms = _servo_set_position(position);
    delay(wait_time_ms);
    return(_servo_position);
}

unsigned long CodeRacer::servo_set_position(uint8_t position)
{
    _servo_sweep = false;
    unsigned long wait_time_ms = _servo_set_position(position);
    return(wait_time_ms);
}

unsigned long CodeRacer::_servo_set_position(uint8_t position)
{
    uint8_t _position = position;
    uint8_t absdiff;

    if (position < SERVO_MIN_POSITION) {
        _position = SERVO_MIN_POSITION;
    }
    else if (position > SERVO_MAX_POSITION) {
        _position = SERVO_MAX_POSITION;
    }
    _servo->write(_position);
    // wait minimal delay to avoid code collaps
    delay(SERVO_SET_1TICK_POSITION_DELAY_MS); 
    absdiff = abs(_servo_position - _position);
    if (absdiff > 1) {
        _servo_position_eta_in_ms = absdiff * SERVO_SET_1TICK_POSITION_DELAY_MS;
    }
    else {
        _servo_position_eta_in_ms = 0;
    }
    
    _servo_position_set_at_ms = millis();
    _servo_position = _position;

    return(_servo_position_eta_in_ms);
}
 // end of group lowerlevelservomeths
uint8_t CodeRacer::servo_position() {
    return(_servo_position);
}

unsigned long CodeRacer::servo_position_set_at_ms() {
    return(_servo_position_set_at_ms);
}

unsigned long CodeRacer::servo_position_eta_in_ms() {
    return(_servo_position_eta_in_ms);
}
 // end of group lowerlevelservogetters // end of group lowerlevelservo


//**************************************
//*** Ultrasonic lower level control ***
//**************************************
unsigned long CodeRacer::usonic_measure_cm()
{
    return(usonic_measure_cm(US_MAX_ECHO_TIME_US));
}

unsigned long CodeRacer::usonic_measure_us()
    {
        return(usonic_measure_us(US_MAX_ECHO_TIME_US));
    }

unsigned long CodeRacer::usonic_measure_cm(unsigned long max_echo_run_time_us)
{
    unsigned long echo_runtime_us = usonic_measure_us(max_echo_run_time_us);
    unsigned long distance_cm = echo_runtime_us * 0.0172;
    //Serial.print("MEASURE_DISTANCE. Distance in cm is: ");
    //Serial.println(distance_cm);
    _usonic_distance_cm = distance_cm;
    return(distance_cm);
}

unsigned long CodeRacer::usonic_measure_us(unsigned long max_echo_run_time_us)
{
    unsigned long echo_runtime_us[3] = { 0,0,0 };
    uint8_t measnr = 0;

    do {
        echo_runtime_us[measnr] = usonic_measure_single_shot_us(max_echo_run_time_us);
        if (echo_runtime_us[measnr] > 200) {
            measnr++;
        }
    } while (measnr < 3);

    // we will take the medium out of 3 values ... 
    if (echo_runtime_us[0] > echo_runtime_us[1]) { std::swap(echo_runtime_us[0], echo_runtime_us[1]); }
    if (echo_runtime_us[1] > echo_runtime_us[2]) { std::swap(echo_runtime_us[1], echo_runtime_us[2]); }
    if (echo_runtime_us[0] > echo_runtime_us[1]) { std::swap(echo_runtime_us[0], echo_runtime_us[1]); }

    //Serial.print("MEASURE_DISTANCE_US. Echo runtime in us is: ");
    //Serial.println(echo_runtime_us[1]);

    // if the stop at minimal distance is enabeled - check for minimal distance is reached
    if (true == _coderacer_stop_at_distance_enabled) {
        if (echo_runtime_us[1] <= _usonic_stop_distance_us) {
            _coderacer_stopped_at_min_distance = true;
            stop_driving();
            _coderacer_stop_at_distance_enabled = false;
        }
    }
    _usonic_distance_us = echo_runtime_us[1];
    return(echo_runtime_us[1]);
}

unsigned long CodeRacer::usonic_measure_single_shot_cm()
{
    return(usonic_measure_single_shot_cm(US_MAX_ECHO_TIME_US));
}

unsigned long CodeRacer::usonic_measure_single_shot_us()
{
    return(usonic_measure_single_shot_us(US_MAX_ECHO_TIME_US));
}

unsigned long CodeRacer::usonic_measure_single_shot_cm(unsigned long max_echo_run_time_us)
{
    // 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;
    unsigned long echo_runtime_us = usonic_measure_single_shot_us(max_echo_run_time_us);
    unsigned long distance_cm = echo_runtime_us * 0.0172;
    //Serial.print("MEASURE_DISTANCE. Distance in cm is: ");
    //Serial.println(distance_cm);
    _usonic_distance_cm = distance_cm;
    return(distance_cm);
}

unsigned long CodeRacer::usonic_measure_single_shot_us(unsigned long max_echo_run_time_us)
    {
        unsigned long echo_runtime_us;
        // start measurement - send a short pulse "HIGH" to the TRIG pin of the ultrasonic sensor
        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);
        // measure runtime in microseconds until the ECHO pin aof the sensor goes HIGH
        echo_runtime_us = pulseInLong(_us_echo_pin, HIGH, max_echo_run_time_us);
        if (echo_runtime_us == 0) {
            echo_runtime_us = max_echo_run_time_us; // US_MAX_ECHO_TIME_US;
        }
        //Serial.print("MEASURE_DISTANCE_US. Echo runtime in us is: ");
        //Serial.println(echo_runtime_us);
        _usonic_distance_us = echo_runtime_us;
        return(echo_runtime_us);
    }
 // end of group lowerlevelusmethods
void CodeRacer::usonic_set_stop_distance_cm(unsigned long stop_distance_cm)
{
    _usonic_stop_distance_us = stop_distance_cm * 58.14;
}

void CodeRacer::usonic_set_stop_distance_us(unsigned long stop_distance_us)
{
    _usonic_stop_distance_us = stop_distance_us;
}

unsigned long CodeRacer::usonic_distance_us() {
    return(_usonic_distance_us);
}

unsigned long CodeRacer::usonic_distance_cm() {
    return(_usonic_distance_cm);
}
 // end of group lowerlevelusgetters // end of group lowerlevelus


//**************************************
//*** Drives lower level control ***
//**************************************

void CodeRacer::drives_settings(uint8_t drive_left_speed, uint8_t drive_right_speed, unsigned long turn_left_for_ms, unsigned long turn_right_for_ms)
{
    _drive_left_speed = drive_left_speed;
    _drive_right_speed = drive_right_speed;
    _turn_left_for_ms = turn_left_for_ms;
    _turn_right_for_ms = turn_right_for_ms;
}

void CodeRacer::set_drives_stop_left_right() {
    set_drive_left_state(DRIVESTOP);
    set_drive_right_state(DRIVESTOP);
}

void CodeRacer::set_drives_states_left_right(drivestate stateleft, drivestate stateright) {
    set_drive_left_state(stateleft);
    set_drive_right_state(stateright);
}

void CodeRacer::set_drive_left_state(drivestate state) {
    set_drive_state(state, _drive_left_frwd_pin, _drive_left_back_pin);
}

void CodeRacer::set_drive_right_state(drivestate state) {
    set_drive_state(state, _drive_right_frwd_pin, _drive_right_back_pin);
}

void CodeRacer::set_drive_state(drivestate state, uint8_t frwdpin, uint8_t backpin) {
    switch (state) {
    case DRIVESTOP:
        digitalWrite(frwdpin, LOW);
        digitalWrite(backpin, LOW);
        break;
    case DRIVEFRWD:
        digitalWrite(frwdpin, HIGH);
        digitalWrite(backpin, LOW);
        break;
    case DRIVEBACK:
        digitalWrite(frwdpin, LOW);
        digitalWrite(backpin, HIGH);
        break;
    }
}

void CodeRacer::set_drives_speed_left_right(uint8_t speedleft, uint8_t speedright) {
    set_drive_left_speed(speedleft);
    set_drive_right_speed(speedright);
}

void CodeRacer::set_drive_left_speed(uint8_t speed) {
    set_drive_speed(speed, _drive_left_enable_pin);
}

void CodeRacer::set_drive_right_speed(uint8_t speed) {
    set_drive_speed(speed, _drive_right_enable_pin);
}

void CodeRacer::set_drive_speed(uint8_t speed, uint8_t enablepin) {
    _analog_write(enablepin, (int)speed);
}
 // end of group lowerleveldrivesmethods
uint8_t CodeRacer::drive_right_speed() {
    return _drive_right_speed;
}

uint8_t CodeRacer::drive_left_speed() {
    return(_drive_left_speed);
}

void CodeRacer::_analog_write(uint8_t pin, uint8_t speed) {
    if (pin == _drive_left_enable_pin) {
        _drive_left_speed = speed;
        ledcWrite(DRIVE_PWM_LEFT_CHANNEL, speed); 
    }
    if (pin == _drive_right_enable_pin) { 
        _drive_right_speed = speed;
        ledcWrite(DRIVE_PWM_RIGHT_CHANNEL, speed); 
    }
}
 // end of group lowerleveldrivesgetters // end of group lowerleveldrives


//**************************************
//*** LED lower level control ***
//**************************************
void CodeRacer::set_leds_left_stop_frwd_right(ledstate leftled, ledstate stopled, ledstate frwdled, ledstate rightled) {
    digitalWrite(_led_left_pin, leftled);
    digitalWrite(_led_frwd_pin, frwdled);
    digitalWrite(_led_right_pin, rightled);
    digitalWrite(_led_stop_pin, stopled);
}

void CodeRacer::set_leds_all(ledstate alleds) {
    digitalWrite(_led_left_pin, alleds);
    digitalWrite(_led_frwd_pin, alleds);
    digitalWrite(_led_right_pin, alleds);
    digitalWrite(_led_stop_pin, alleds);
}

void CodeRacer::set_leds_all_off() {
    set_leds_all(LEDOFF);
}

void CodeRacer::set_leds_all_on() {
    set_leds_all(LEDON);
}
 // end of group lowerlevelledmets // end of group lowerlevelled


//**************************************
//*** ISRs ***
//**************************************
//IRAM_ATTR is used to load the code into DRAM and not to Flash to make it faster - required for ISRs
void IRAM_ATTR CodeRacer::_set_button_state() {
    if ((millis() - button_last_pressed_at_ms) > BUTTON_BOUNCING_TIME_MS) {
        button_last_pressed_at_ms = millis();           // simplest debouncing - just wait ;-)
        coderracer_activ = !coderracer_activ;
    }
}


//**********************************************************************************************************************
//**  Methods below this are obsolete and only in here for compatiblity to other projects - do not use them anymore !!!
//**********************************************************************************************************************
void CodeRacer::motor_einstellungen(uint8_t drive_left_speed, uint8_t drive_right_speed, unsigned long turn_left_for_ms, unsigned long turn_right_for_ms)
{
    drives_settings(drive_left_speed, drive_right_speed, turn_left_for_ms, turn_right_for_ms);
}

void CodeRacer::servo_einstellungen(uint8_t pos_center, uint8_t pos_left, uint8_t pos_right, uint8_t sweep_left_pos, uint8_t sweep_right_pos)
{
    servo_settings(pos_center, pos_left, pos_right, sweep_left_pos, sweep_right_pos);
}

void CodeRacer::servo_rechts()
{
    Serial.println("SERVO_RECHTS");                                                             // Meldung am Monitor ausgeben
    servo_set_to_right();                                                                                   // Servo auf den Winkel rechts drehen
}

void CodeRacer::servo_links()
{
    Serial.println("SERVO_LINKS");                                                                  // Meldung am Monitor ausgeben
    servo_set_to_left();                                                                        // Servo auf den Winkel links drehen
}

void CodeRacer::servo_mitte()
{
    Serial.println("SERVO_MITTE");
    servo_set_to_center();
}

void CodeRacer::servo_schwenk()
{
    servo_sweep();
}

void CodeRacer::links()
{
    Serial.println("CODERACER_LINKS");
    turn_left();
}

void CodeRacer::rechts()
{
    Serial.println("CODERACER_RECHTS");
    turn_right();
}

void CodeRacer::anhalten()
{
    Serial.println("CODERACER_ANHALTEN");
    stop_driving();
}

void CodeRacer::vorwaerts()
{
    Serial.println("CODERACER_VORWAERTS");
    drive_forward();
}

void CodeRacer::rueckwaerts()
{
    Serial.println("CODERACER_RUECKWAERTS");
    drive_backward();
}

unsigned long CodeRacer::abstand_messen()
{
    return(0);
    
    unsigned long distance_cm = 0;
    unsigned long min_distance_cm = 1000;
    int8_t servo_turn_direction = 0;


    // while driving or sweeping there will be only one value be measured - else there will be mutiple measurements and the servor will be turning
    if (((true == _drive) || (servo_center_pos == _servo_position) || _servo_sweep == true)) {
        // while driving ...
        //Serial.println("ABSTAND_MESSEN im fahren, direkt nach vorn oder Schwenk() ist aktiv ...");
        min_distance_cm = usonic_measure_cm();
    }   else {
        // no sweep, not driving ...
        //Serial.println("ABSTAND_MESSEN im Stand nach links oder rechts...");
        // are we already ath left or right with the servo ?
        if (servo_left_pos == _servo_position) {
            //Serial.println("ABSTAND_MESSEN. Linke Seite.");
            //left ...
            servo_turn_direction = SERVO_SWEEP_TO_RIGHT_STEP;
        }
        if (servo_right_pos == _servo_position) {
            //right ...
            //Serial.println("ABSTAND_MESSEN rechte Seite.");
            servo_turn_direction = SERVO_SWEEP_TO_LEFT_STEP;
        }
        // trun the servo and do measuring ... remember the smallest value
        do {
            _servo_set_position(_servo_position + servo_turn_direction);
            //Serial.print("ABSTAND_MESSEN. Servo position:");
            //Serial.println(_servo_position);
            distance_cm = usonic_measure_cm();
            if (distance_cm < min_distance_cm) {
                min_distance_cm = distance_cm;
            }
        } while ((_servo_position > H_SERVO_CENTER_LEFT) || (_servo_position < H_SERVO_CENTER_RIGHT));
    }

    Serial.print("ABSTAND_MESSEN. Der Abstand in cm ist (mindestens):");
    Serial.println(min_distance_cm);
    //_min_distance_cm = min_distance_cm;

    return(min_distance_cm);

}

//**********************************************************************************************************************
//**  Helper methods
//**********************************************************************************************************************