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>

#define True 1

#define False 0

#define NRT 1111111

#define HRT 0000000

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;

}

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);

}

/** Initialize rtcan

void rtcanInit(){

    //necessary?

}

/** Start rtcan *

void rtcanStart(CANDriver *canp, const CANConfig *config){

    can_lld_Start(canp,config);

}

/** Stop rtcan *

void rtcanStop(CANDriver *canp){

    can_lld_Stop(canp);

}

/** Stop rtcan reset param and start again *

void rtcanReset(){}

*

msgqueue_t msgqueueInit(rtcan_msg_t* msg){

    struct msgqueue_t queue;

    queue->head = msg;

    queue->tail = msg;

    return queue;

}

/** enqueue rtcanmsg_t  *

void msgqueueEnqueue(msgqueue_t* mqueue,rtcan_msg_t* msg){

    if(!msgqueueEmpty(mqueue)){

    // HRT message most imminent so enqueued at head

        msgqueue_t* curMsg = mqueue->tail;

        while(curMsg->prev != mqueue->head){

            if(msg->laxity < curMsg->laxity){

                break;

            }

            curMsg = curMsg->prev;

        }

        //what about the tail?

        msg->prev = curMsg->prev;

        curMsg->prev = msg;

    }else{

        msgqueueInit(msg);

    }

}

/** dequeue rtcanmsg *

rtcan_msg_t* msgqueueDequeue(msgqueue_t* mqueue){

    if(!msgqueueEmpty(mqueue)){

        rtcan_msg_t dq = mqueue->head;

        mqueue->head = dq->prev;

        return dq;

    }

    return NULL;

}

/** empty or clear?*/

int msgqueueEmpty(msgqueue_t* mqueue){

    if(mqueue == NULL){

        return True;

    }

    return False;

}

//TODO: ISR

//TODO: Params