AMiRo-OS

/*

AMiRo-OS is an operating system designed for the Autonomous Mini Robot (AMiRo) platform.

Copyright (C) 2016..2018  Thomas Schöpping et al.

This program is free software: you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation, either version 3 of the License, or

(at your option) any later version.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program.  If not, see <http://www.gnu.org/licenses/>.

*/

#include <hal.h>

#include <hal_can.h>

#include <hal_can_lld.h>

#include <aos_rtcan.h>

#include <aos_thread.h>

#include <chtime.h>

#include <ch.h>

#include <stdbool.h>

#define True 1

#define False 0

#define HRTMSG 00

#define SRTMSG 01

#define NRTMSG 11

#define SLEEPTIME 20

/**

 * @brief Event mask to identify rtcan message events.

 */

#define RTCANEVENT_MASK                         EVENT_MASK(5)

// need to be initialized somewhere

msgqueue_t hrtQueue;

msgqueue_t srtQueue;

msgqueue_t nrtQueue;

event_source_t msgEventSource;

/*

 * @brief transmit Message over CAN

 */

msg_t rtcan_transmit(CANDriver *canp, canmbx_t mailbox, const CANTxFrame *ctfp){

    // call cantransmit, needed params driver, mailbox and tx frame

    msg_t transmit = canTransmitTimeout(canp,mailbox,ctfp,TIME_IMMEDIATE);

    return transmit;

}

/*

 * @brief receive Message over CAN

 */

msg_t rtcan_receive(CANDriver *canp, canmbx_t mailbox,CANRxFrame *crfp){

    // call lld cantransmit, needed params driver, mailbox and rx frame

    return canReceiveTimeout(canp,mailbox,crfp,TIME_IMMEDIATE);

}

bool pushRTCanMsgSorted(rtcan_msg_t *msg,msgqueue_t* msgqueue){

    rtcan_msg_t * prevElem = msgqueue->head;

    rtcan_msg_t * compareElem = prevElem->next;

    while(ST2MS(msg->deadline) >= ST2MS(compareElem->deadline)){

        if(compareElem->next != NULL){

            prevElem = compareElem;

            compareElem = compareElem->next;

        }else{

            prevElem->next = msg;

            msgqueue->tail = msg;

            msgqueue->size++;

            return true;

        }

    }

    if(compareElem!= NULL){

      msg->next = compareElem;

    }

    return false;

}

/*

 * @brief push Message to its Queue, based on type of Message

 */

bool pushRTCanMsg(rtcan_msg_t *msg,msgqueue_t* msgqueue){

  if(msg != NULL){

    if(msgqueueEmpty(msgqueue)){

        queueInit(msg,msgqueue);

        return true;

    }

      msgqueue->tail->next = msg;

      msg->next = NULL;

      msgqueue->tail = msg;

      msgqueue->size++;

      return true;

    }

  return false;

}

/*

 * @brief dequeue Message from Queue

 */

rtcan_msg_t* popRTCanMsg(msgqueue_t* msgqueue){

    //todo special case head = tail

  if(!msgqueueEmpty(msgqueue)){

      rtcan_msg_t *elem = msgqueue->head;

      msgqueue->head = elem->next;

      msgqueue->size--;

      return elem;

  }

  return NULL;

}

/*

 * @brief init Message Queue

 */

void queueInit(rtcan_msg_t *head,msgqueue_t* msgqueue){

  msgqueue->size = 0;

  msgqueue->head = head;

  msgqueue->tail = head;

  head->next = NULL;

  msgqueue->size++;

}

// Handling Message Queues

bool enqueueMsg(uint8_t *payload, uint8_t msgType, aos_timestamp_t deadline){

  static rtcan_msg_t msg;

  msg.payload = payload;

  msg.msgType = msgType;

  msg.deadline = deadline;

  if(msgType == HRTMSG){

    return pushRTCanMsg(&msg,&hrtQueue);

  }else if(msgType == SRTMSG){

    return pushRTCanMsgSorted(&msg,&srtQueue);

  }else if(msgType == NRTMSG){

    return pushRTCanMsg(&msg,&nrtQueue);

  }

  return false;

}

u_int32_t createId(rtcan_msg_t *msg, uint8_t msgType){

    // first 6 bit laxity

    // 6-21 id, einfach irgendetwas eindeutiges

    // 22-28 fragment

    // Differenz

    u_int32_t id = 0;

    aos_timestamp_t uptime;

    aosSysGetUptime(&uptime);

}

static THD_WORKING_AREA(queueThdWorkingArea,128);

static THD_FUNCTION(queueThd,arg){

    event_listener_t msgListener;

    chEvtRegisterMask(&msgEventSource,&msgListener,RTCANEVENT_MASK);

    while(true){

      eventmask_t evt = chEvtWaitAny(RTCANEVENT_MASK);

    }

}

/**

 * @brief schedule rtcan messages into mailboxes

 */

static THD_WORKING_AREA(SendThdWorkingArea, 128);

//todo rename

static THD_FUNCTION(rtcanSendThd,arg){

  chRegSetThreadName("RTCAN Timer");

  int nextSlot; // set by while loop from calendar

  while (true){

    // send Frame of Timeslot

    // iterate over calendar(bitmask)

    rtcan_msg_t *nextMsg;

    chThdSleepMilliseconds( SLEEPTIME );

    if(nextSlot == 1){

      nextMsg = popRTCanMsg(&hrtQueue);

    }else{

      if(!msgqueueEmpty(srtQueue)){

        nextMsg = popRTCanMsg(&srtQueue);

      }else{

        nextMsg = popRTCanMsg(&nrtQueue);

      }

    }

    if(nextMsg != NULL){

      // create frame

      // frame needs id, payload(later) and ___

      // place it in Mailbox to be sent in next time slot

    }

    // in reserved slot should a message be sent

    chThdSleepMilliseconds( SLEEPTIME );

  }

  return 0;

}

/** empty or clear?*/

int msgqueueEmpty(msgqueue_t* mqueue){

    if(mqueue == NULL){

        return true;

    }

    return false;

}

//TODO: ISR

//TODO: Params