File content as of revision 0:84a8c24e29ae:

#include "mbed.h"
#include "class_ventouse.h"
#include "ident_CRAC.h"
#include "def.h"

#define SIZE_FIFO 50

CAN can(PB_8,PB_9,1000000);
Serial pc(USBTX,USBRX);
Ticker tick;

CANMessage msgRxBuffer[SIZE_FIFO];
unsigned char FIFO_ecriture=0; //Position du fifo pour la reception CAN
signed char FIFO_lecture=0;//Position du fifo de lecture des messages CAN

Ventouse* ventouse[8];
char end_game = 0;


void get_etat_ventouses();
void isr_pression();

//ajouter ticker pour isr_presison

/*********************************************************************************************************/
/* FUNCTION NAME: canRx_ISR                                                                              */
/* DESCRIPTION  : lit les messages sur le can et les stocke dans la FIFO                                 */
/*********************************************************************************************************/
void canRx_ISR (void)
{
    if (can.read(msgRxBuffer[FIFO_ecriture]))
        FIFO_ecriture=(FIFO_ecriture+1)%SIZE_FIFO;
}


/*********************************************************************************************************/
/* FUNCTION NAME: canProcessRx                                                                           */
/* DESCRIPTION  : Fonction de traitement des messages CAN                                                */
/*********************************************************************************************************/
void canProcessRx(void){
    static signed char FIFO_occupation=0,FIFO_max_occupation=0;
    CANMessage msgTx=CANMessage();
    FIFO_occupation=FIFO_ecriture-FIFO_lecture;
    if(FIFO_occupation<0)
        FIFO_occupation=FIFO_occupation+SIZE_FIFO;
    if(FIFO_max_occupation<FIFO_occupation)
        FIFO_max_occupation=FIFO_occupation;
    if(FIFO_occupation!=0) {
    int identifiant=msgRxBuffer[FIFO_lecture].id;
    int BRAS = msgRxBuffer[FIFO_lecture].data[0];
        switch(identifiant){
            
            #ifdef ROBOT_SMALL
            case HACHEUR_GET_ATOM:
                pc.printf("HACHEUR_GET_ATOM bras %d\n", int(BRAS));
                ventouse[BRAS]->attraper();
                break;
            
            case HACHEUR_RELEASE_ATOM:
                pc.printf("HACHEUR_RELEASE_ATOM\n");
                ventouse[BRAS]->relacher(); 
                break;              
            
            case HACHEUR_GET_DISTRIB_AR:
                pc.printf("HACHEUR_GET_DISTRIB_AR\n");            
                ventouse[AR_GAUCHE]->attraper();
                ventouse[AR_CENTRE]->attraper();
                ventouse[AR_DROIT]->attraper();
                break;
            
            case HACHEUR_GET_DISTRIB_AV:
                //SendAck();
                pc.printf("HACHEUR_GET_DISTRIB_AV\n"); 
                ventouse[AV_GAUCHE]->relacher();
                ventouse[AV_CENTRE]->relacher();
                ventouse[AV_DROIT]->relacher();
                break;
            
            case HACHEUR_STATUT_VENTOUSES:
                pc.printf("HACHEUR_GET_STATUS\n");
                get_etat_ventouses();
                break;
            
            case GLOBAL_GAME_END:
                end_game = 1;
                break;
            #endif

            #ifdef ROBOT_BIG
            
            #endif
        }
        FIFO_lecture=(FIFO_lecture+1)%SIZE_FIFO;
    }
}

int main() {
    
    char i =0;

    pc.printf("Hello World");
    can.attach(&canRx_ISR); // création de l'interrupt attachée à la réception sur le CAN
    //tick.attach(&isr_pression, 0.5);
    wait(1);
   // #ifdef ROBOT_SMALL
    //DEFINITION DES VENTOUSES
    ventouse[AV_GAUCHE] = new Ventouse(PC_9, PA_8, PB_0);
    ventouse[AV_CENTRE] = new Ventouse(PA_9, PA_10,  PB_1);
    ventouse[AV_DROIT]  = new Ventouse(PA_11, PA_15, PC_1);
    ventouse[AV_BAS]    = new Ventouse(PB_7, PB_6, PC_0);
    
    ventouse[AR_GAUCHE] = new Ventouse(PC_7,PC_8 , PC_5);
    ventouse[AR_CENTRE] = new Ventouse(PB_10, PB_2, PC_4);
    ventouse[AR_DROIT]  = new Ventouse(PA_6, PA_5, PA_7);
    ventouse[AR_BAS]    = new Ventouse(PA_0, PA_1, PA_4);
    

   // #endif
    
    while(1) {
        canProcessRx();
        pc.printf("%d\n",i);
        i++;
        wait_ms(10);
        //isr_pression();
        if(end_game){
            for(int i=0; i<8;i++){
                ventouse[i]->setPompe(0.0);
                ventouse[i]->setElectrovanne(0.0);
            }
            while(1){;}
        }
    }
}




void get_etat_ventouses()
{   
    CANMessage etat_ventouses = CANMessage();
    etat_ventouses.id=HACHEUR_STATUT_VENTOUSES;      
    etat_ventouses.len=2;
    etat_ventouses.format=CANStandard;
    etat_ventouses.type=CANData;
    for(int i=7; i>=0; i--){
        etat_ventouses.data[0] = (etat_ventouses.data[0]<<1) + ventouse[i]->getPompe();
        etat_ventouses.data[1] = (etat_ventouses.data[1]<<1) + ventouse[i]->getPression();       
    }
    can.write(etat_ventouses);

}

void isr_pression()
{   
    static char i = 1;
    can.write(CANMessage(100,&i,1));
    i++;
    /*
    static char new_pression = 0;
    static char old_pression = 0;
    
    for(int i=7; i>=0; i--){
        new_pression = (new_pression<<1) + ventouse[i]->getPression();
    }
    
    if(old_pression^new_pression){
        CANMessage chgt_pression = CANMessage();
        chgt_pression.id=HACHEUR_ISR_PRESSION ;      
        chgt_pression.len=2;
        chgt_pression.format=CANStandard;
        chgt_pression.type=CANData;
        chgt_pression.data[0] = old_pression^new_pression ;
        chgt_pression.data[1] = new_pression;
        can.write(chgt_pression);
    }
    
    new_pression = old_pression; 
    */
    

}