AMiRo-OS

#include "userthread.hpp"

#include "global.hpp"

#include "linefollow.hpp" 

using namespace amiro;

extern Global global;

// a buffer for the z-value of the accelerometer

int16_t accel_z;

bool running = false;

/**

 * Set speed.

 * 

 * @param rpmSpeed speed for left and right wheel in rounds/min

 */

void UserThread::setRpmSpeed(const int (&rpmSpeed)[2]) {

  global.motorcontrol.setTargetRPM(rpmSpeed[constants::DiWheelDrive::LEFT_WHEEL] * 1000000, rpmSpeed[constants::DiWheelDrive::RIGHT_WHEEL] * 1000000);

}

void UserThread::lightOneLed(Color color, int idx){

  global.robot.setLightColor(idx, Color(color));

}

void UserThread::lightAllLeds(Color color){

  int led = 0;

  for(led=0; led<8; led++){

        lightOneLed(color, led);

      }

}

void UserThread::showChargingState(){

  uint8_t numLeds = global.robot.getPowerStatus().state_of_charge / 12;

  Color color = Color::GREEN;

  if (numLeds <= 2){

    color = Color::RED;

  }else if(numLeds <= 6){

    color = Color::YELLOW;

  }

  for (int i=0; i<numLeds; i++){

    lightOneLed(color, i);

    this->sleep(300);

  }

  this->sleep(1000);

  lightAllLeds(Color::BLACK);

}

/**

 * Blocks as long as the position changes.

 */

void UserThread::checkForMotion(){

  int motion = 1;

  int led = 0;

  types::position oldPos = global.odometry.getPosition();

  while(motion){

    this->sleep(500);

    types::position tmp = global.odometry.getPosition();

    motion = abs(oldPos.x - tmp.x)+ abs(oldPos.y - tmp.y)+abs(oldPos.z - tmp.z);

    oldPos = tmp;

      global.robot.setLightColor((led + 1) % 8, Color(Color::YELLOW));

      global.robot.setLightColor(led % 8, Color(Color::BLACK));

      led++;

  }

}

bool UserThread::checkPinVoltage(){

  return global.ltc4412.isPluggedIn(); 

}

bool UserThread::checkPinEnabled(){

  return global.ltc4412.isEnabled();

}

int UserThread::checkDockingSuccess(){

  // setRpmSpeed(stop);

  checkForMotion();

  int success = 0;

  global.odometry.resetPosition();

  types::position start = global.startPos = global.odometry.getPosition();

  global.motorcontrol.toggleMotorEnable();

  this->sleep(1000);

  types::position stop_ = global.endPos = global.odometry.getPosition();

  // Amiro moved, docking was not successful

  if ((start.x + stop_.x) || (start.y + stop_.y)){

    lightAllLeds(Color::RED);

    // Enable Motor again if docking was not successful

    global.motorcontrol.toggleMotorEnable();

    success = 0;

  }else{

    lightAllLeds(Color::GREEN);

    success = 1;

  }

  this->sleep(500);

  lightAllLeds(Color::BLACK);

  return success;

}

UserThread::UserThread() :

  chibios_rt::BaseStaticThread<USER_THREAD_STACK_SIZE>()

{

}

UserThread::~UserThread()

{

}

msg_t

UserThread::main()

{

  /*

   * SETUP

   */

  // User thread state:

states utState = states::IDLE;

states newState;

   int whiteBuf = 0;

   int correctionStep = 0;

  int rpmSpeed[2] = {0};

  int stop[2] = {0};

  LineFollowStrategy lStrategy = LineFollowStrategy::FUZZY;

  for (uint8_t led = 0; led < 8; ++led) {

    global.robot.setLightColor(led, Color(Color::BLACK));

  }

  running = false;

  LineFollow lf(&global);

  /*

   * LOOP

   */

  while (!this->shouldTerminate())

  {

    /*

    * read accelerometer z-value

    */

    accel_z = global.lis331dlh.getAccelerationForce(LIS331DLH::AXIS_Z);

    if (accel_z < -900 /*-0.9g*/) { 

      // Start line following when AMiRo is rotated

      if(utState == states::IDLE){

        utState = states::FOLLOW_LINE;

      }else{

        utState = states::IDLE;

      }

      lightAllLeds(Color::GREEN);

      this->sleep(1000);

      lightAllLeds(Color::BLACK);

    // If message was received handle it here:

    } else if(global.msgReceived){

      global.msgReceived = false;

      // running = true;

      switch(global.lfStrategy){

        case msg_content::START:

          utState = states::FOLLOW_LINE;

          break;

        case msg_content::STOP:

          utState = states::IDLE;

          break;

        case msg_content::EDGE_RIGHT:

          // utState = states::FOLLOW_LINE;

          lStrategy = LineFollowStrategy::EDGE_RIGHT;

          break;

        case  msg_content::EDGE_LEFT:

          // utState = states::FOLLOW_LINE;

          lStrategy = LineFollowStrategy::EDGE_LEFT;

          break;

        case msg_content::FUZZY:

          // utState = states::FOLLOW_LINE;

          lStrategy = LineFollowStrategy::FUZZY;

          break;

        case msg_content::DOCK:

          utState = states::DETECT_STATION;

          break;

        case msg_content::UNDOCK:

          utState = states::RELEASE;

          break;

        case msg_content::CHARGE:

          utState = states::CHARGING;

          break;

        default:

          utState = states::IDLE;

          break;

      }

    }

    newState = utState;

    // Get sensor data 

    int WL = global.vcnl4020[constants::DiWheelDrive::PROX_WHEEL_LEFT].getProximityScaledWoOffset();

    int WR = global.vcnl4020[constants::DiWheelDrive::PROX_WHEEL_RIGHT].getProximityScaledWoOffset();

    // int FL = global.vcnl4020[constants::DiWheelDrive::PROX_FRONT_LEFT].getProximityScaledWoOffset();

    // int FR = global.vcnl4020[constants::DiWheelDrive::PROX_FRONT_RIGHT].getProximityScaledWoOffset();

    switch(utState){

      case states::IDLE:

        if (!global.motorcontrol.getMotorEnable()){

            global.motorcontrol.toggleMotorEnable();

        }

        setRpmSpeed(stop);

        if(/* checkPinVoltage() && */ checkPinEnabled()){

          global.robot.requestCharging(0);

        }

        break;

      // ---------------------------------------

      case states::FOLLOW_LINE:

      // Set correct forward speed to every strategy

        if (global.forwardSpeed != global.rpmForward[0]){

          global.forwardSpeed = global.rpmForward[0];

        }

        if(lf.getStrategy() != lStrategy){

          lf.setStrategy(lStrategy);

        }

        //TODO: Check if white is detected and stop threshold is reached

        if(lf.followLine(rpmSpeed)){

          if(whiteBuf >= WHITE_COUNT_THRESH){

            setRpmSpeed(stop);

            newState = states::IDLE;

          }else{

            whiteBuf++;

          }

        }else{

          whiteBuf = 0;

          setRpmSpeed(rpmSpeed);

        }

        // lf.followLine(rpmSpeed);

        // setRpmSpeed(rpmSpeed);

        break;

      // ---------------------------------------

      case states::DETECT_STATION:

        if (global.forwardSpeed != CHARGING_SPEED){

          global.forwardSpeed = CHARGING_SPEED;

        }

        if(lf.getStrategy() != LineFollowStrategy::EDGE_RIGHT){

          lf.setStrategy(LineFollowStrategy::EDGE_RIGHT);

        }

        lf.followLine(rpmSpeed);

        setRpmSpeed(rpmSpeed);

        // // Detect marker before docking station

        if ((WL+WR) < PROXY_WHEEL_THRESH){

          setRpmSpeed(stop);

          checkForMotion();

          // 180° Rotation 

          global.distcontrol.setTargetPosition(0, ROTATION_180, ROTATION_DURATION);

          // BaseThread::sleep(8000);

          checkForMotion();

          newState = states::CORRECT_POSITIONING;

        }

        break;

      // ---------------------------------------

      case states::CORRECT_POSITIONING:

        if(lf.getStrategy() != LineFollowStrategy::EDGE_LEFT){

          lf.promptStrategyChange(LineFollowStrategy::EDGE_LEFT);

        }

        lf.followLine(rpmSpeed);

        setRpmSpeed(rpmSpeed);

        correctionStep++;

        if (correctionStep >= MAX_CORRECTION_STEPS){

          correctionStep = 0;

          newState = states::REVERSE;

          setRpmSpeed(stop);

          checkForMotion();

        }

        break;

      // ---------------------------------------

      case states::REVERSE:

        if(lf.getStrategy() != LineFollowStrategy::REVERSE){

          lf.setStrategy(LineFollowStrategy::REVERSE);

        }

        lf.followLine(rpmSpeed);

        setRpmSpeed(rpmSpeed);

        if ((WL+WR) < PROXY_WHEEL_THRESH){

          setRpmSpeed(stop);

          checkForMotion();

          newState = states::CHECK_POSITIONING;

        }

        break;

      // ---------------------------------------

      case states::CHECK_POSITIONING:

        if(checkDockingSuccess()/* && checkVoltage() */){

          newState = states::CHARGING;

        }else{

          newState = states::CORRECT_POSITIONING;

        }

        break;

      // ---------------------------------------

      case states::CHARGING:

        if (global.motorcontrol.getMotorEnable()){

          global.motorcontrol.toggleMotorEnable();

        }

        // Formulate Request to enable charging

        if(/* checkPinVoltage() && */ !checkPinEnabled()){

          global.robot.requestCharging(1);

        }

        if(checkPinEnabled()){

          showChargingState();

        }

        break;

      // ---------------------------------------

      case states::RELEASE:

        if(/* checkPinVoltage() && */ checkPinEnabled()){

          global.robot.requestCharging(0);

        }

        if(checkPinEnabled()){

          showChargingState();

        }else{

          if (!global.motorcontrol.getMotorEnable()){

            global.motorcontrol.toggleMotorEnable();

          }

          //Rotate -20° to free from magnet

          global.distcontrol.setTargetPosition(0, ROTATION_20, ROTATION_DURATION);

          checkForMotion();

          lStrategy = LineFollowStrategy::EDGE_RIGHT;

          newState = states::FOLLOW_LINE;

        }

        lightAllLeds(Color::BLACK);

        break;

      default:

        break;

      }

      utState = newState;

    this->sleep(CAN::UPDATE_PERIOD);

  }

  return RDY_OK;

}