Arduino↔Chef: Ajout côté chef & corrections

arduino/AC.c

@@ -1,35 +1,37 @@
 #include "AC.h"
 
-void registerRxHandler(unsigned char code, rxHandler handler)
+void registerRxHandlerAC(unsigned char code, rxHandler handler)
 {
-    rxHandlers[code] = handler;
+    rxHandlersAC[code] = handler;
 }
 
-
 ISR(USART0_UDRE_vect)
 {
     // When a transmit is ready to be done again
-    TaskHandle_t holder = xSemaphoreGetMutexHolder(sSendAC);
-    if (holder != NULL) {
-        vTaskResume(holder);
+    UDR0 = *toSendAC;
+    toSendAC++;
+    toSendSizeAC--;
+    if (toSendSizeAC <= 0) {
+        UCSR0B &= ~(1 << UDRIE0);
+        TaskHandle_t holder = xSemaphoreGetMutexHolder(sSendAC);
+        if (holder != NULL) {
+            vTaskNotifyGiveFromISR(holder, NULL);
+        }
     }
 }
 
-void sendByteAC(unsigned char data)
-{
-    while (!bit_is_set(UCSR0A, UDRE0)) {
-        vTaskSuspend(xSemaphoreGetMutexHolder(sSendAC));
-    }
-    UDR0 = data;
-}
-
 void sendAC(unsigned char code, void* data, size_t size)
 {
-    xSemaphoreTake(sSendAC, 0);
-    sendByteAC(code);
-    unsigned char* p = data;
-    for (int i = 0; i < size; i++) {
-        sendByteAC(*p++);
+    xSemaphoreTake(sSendAC, portMAX_DELAY);
+    toSendAC = &code;
+    toSendSizeAC = sizeof(code);
+    UCSR0B |= (1 << UDRIE0);
+    ulTaskNotifyTake(pdFALSE, portMAX_DELAY);
+    if (size > 0) {
+        toSendAC = data;
+        toSendSizeAC = size;
+        UCSR0B |= (1 << UDRIE0);
+        ulTaskNotifyTake(pdFALSE, portMAX_DELAY);
     }
     xSemaphoreGive(sSendAC);
 }
@@ -37,15 +39,16 @@ void sendAC(unsigned char code, void* data, size_t size)
 ISR(USART0_RX_vect)
 {
     // When a character is received
-    vTaskResume(tReaderAC);
+    vTaskNotifyGiveFromISR(tReaderAC, NULL);
 }
 
 unsigned char readByteAC()
 {
     while (!bit_is_set(UCSR0A, RXC0)) {
-        vTaskSuspend(tReaderAC);
+        ulTaskNotifyTake(pdFALSE, portMAX_DELAY);
     }
-    return UDR0;
+    unsigned char c = UDR0;
+    return c;
 }
 
 void readAC(void* data, size_t size)
@@ -64,16 +67,21 @@ void TaskReaderAC(void* pvParameters)
     for (;;) {
         code = readByteAC();
 
-        rxHandler handler = rxHandlers[code];
+        rxHandler handler = rxHandlersAC[code];
         if (handler != NULL) {
             handler();
         } else {
-            struct A2CI_ERRs err = { ERR_UNKNOWN_CODE };
+            struct A2CD_ERRs err = { ERR_UNKNOWN_CODE };
             sendAC(A2CD_ERR, &err, sizeof(err));
         }
     }
 }
 
+void onC2AD_PING()
+{
+    sendAC(C2AD_PING, NULL, 0);
+}
+
 void configureAC()
 {
     /* Set baud rate */
@@ -83,14 +91,16 @@ void configureAC()
     UCSR0A &= ~(1 << U2X0);
 
     /* Enable transmitter & receiver with interrupts */
-    UCSR0B = (1 << RXCIE0 | 1 << UDRIE0 | 1 << TXEN0 | 1 << RXEN0);
+    UCSR0B = (1 << RXCIE0 | 1 << TXEN0 | 1 << RXEN0);
 
     /* Set 8 bits character and 1 stop bit */
     UCSR0C = (1 << UCSZ01 | 1 << UCSZ00);
 
     for (int i = 0; i < 256; i++) {
-        rxHandlers[i] = NULL;
+        rxHandlersAC[i] = NULL;
     }
     sSendAC = xSemaphoreCreateMutex();
     xTaskCreate(TaskReaderAC, "TaskReaderAC", 128, NULL, 2, &tReaderAC);
+
+    registerRxHandlerAC(C2AD_PING, onC2AD_PING);
 }

arduino/AC.h

@@ -2,8 +2,8 @@
  * Définition des fonctions utilisées pour échager entre l'Arduino et le chef
  */
 
-#ifndef __SERIAL_H_
-#define __SERIAL_H_
+#ifndef __AC_H_
+#define __AC_H_
 
 #include <FreeRTOS.h>
 #include <avr/interrupt.h>
@@ -19,16 +19,17 @@
 
 TaskHandle_t tReaderAC;
 SemaphoreHandle_t sSendAC;
+unsigned char* toSendAC;
+size_t toSendSizeAC;
 
 typedef void (*rxHandler)(void);
-rxHandler rxHandlers[256];
+rxHandler rxHandlersAC[256];
 
-void registerRxHandler(unsigned char code, rxHandler handler);
-void sendByteAC(unsigned char data);
+void registerRxHandlerAC(unsigned char code, rxHandler handler); // À utiliser après configureAC();
 void sendAC(unsigned char code, void* data, size_t size);
 unsigned char readByteAC(); // À utiliser uniquement depuis un rxHandler
 void readAC(void* data, size_t size); // À utiliser uniquement depuis un rxHandler
-void TaskReaderAC(void* pvParameters);
+void TaskReaderAC(void* pvParameters); // Privé
 void configureAC();
 
 #endif

arduino/ACsignals.h

@@ -8,7 +8,7 @@
 #define AC_BAUDRATE 9600UL
 
 // Structures used everywhere
-struct position {
+struct __attribute__ ((packed)) position {
     float x;
     float y;
     float o;
@@ -30,13 +30,9 @@ struct position {
 
 // Pour le debug
 #define C2AD_PING 'P'
-struct C2AD_PINGs {
-};
 
 // Arrête tous les actionneurs
 #define C2AD_STOP 'S'
-struct C2ADD_STOPs {
-};
 
 // Donne une destination
 #define C2AD_GOTO 'G'
@@ -47,15 +43,16 @@ struct C2ADD_STOPs {
 
 // Erreur quelconque
 #define A2CD_ERR 'E'
-struct A2CI_ERRs {
+struct __attribute__ ((packed)) A2CD_ERRs {
     unsigned char code;
 };
 
 #define ERR_UNKNOWN_CODE 'C'
+#define ERR_UNKNOWN_CODE_FPGA 'c'
 
 // Envoie les infos de debug
 #define A2CI_DBG 'D'
-struct A2CI_DBGs {
+struct __attribute__ ((packed)) A2CI_DBGs {
     struct position actuel;
     struct position destination;
     unsigned char movement;

arduino/AF.c

@@ -0,0 +1,99 @@
+#include "AF.h"
+#include "AC.h"
+
+void registerRxHandlerAF(unsigned char code, rxHandler handler)
+{
+    rxHandlersAF[code] = handler;
+}
+
+ISR(USART1_UDRE_vect)
+{
+    // When a transmit is ready to be done again
+    UDR1 = *toSendAF;
+    toSendAF++;
+    toSendSizeAF--;
+    if (toSendSizeAF <= 0) {
+        UCSR1B &= ~(1 << UDRIE0);
+        TaskHandle_t holder = xSemaphoreGetMutexHolder(sSendAF);
+        if (holder != NULL) {
+            vTaskNotifyGiveFromISR(holder, NULL);
+        }
+    }
+}
+
+void sendAF(unsigned char code, void* data, size_t size)
+{
+    xSemaphoreTake(sSendAF, portMAX_DELAY);
+    toSendAF = &code;
+    toSendSizeAF = sizeof(code);
+    UCSR1B |= (1 << UDRIE0);
+    ulTaskNotifyTake(pdFALSE, portMAX_DELAY);
+    if (size > 0) {
+        toSendAF = data;
+        toSendSizeAF = size;
+        UCSR1B |= (1 << UDRIE0);
+        ulTaskNotifyTake(pdFALSE, portMAX_DELAY);
+    }
+    xSemaphoreGive(sSendAF);
+}
+
+ISR(USART1_RX_vect)
+{
+    // When a character is received
+    vTaskNotifyGiveFromISR(tReaderAF, NULL);
+}
+
+unsigned char readByteAF()
+{
+    while (!bit_is_set(UCSR1A, RXC1)) {
+        ulTaskNotifyTake(pdFALSE, portMAX_DELAY);
+    }
+    return UDR1;
+}
+
+void readAF(void* data, size_t size)
+{
+    unsigned char* p = data;
+    for (int i = 0; i < size; i++) {
+        *p = readByteAF();
+        p++;
+    }
+}
+
+void TaskReaderAF(void* pvParameters)
+{
+    (void)pvParameters;
+    unsigned char code;
+    for (;;) {
+        code = readByteAF();
+
+        rxHandler handler = rxHandlersAF[code];
+        if (handler != NULL) {
+            handler();
+        } else {
+            struct A2CD_ERRs err = { ERR_UNKNOWN_CODE_FPGA };
+            sendAC(A2CD_ERR, &err, sizeof(err));
+        }
+    }
+}
+
+void configureAF()
+{
+    /* Set baud rate */
+    UBRR1 = AF_PRESCALER;
+
+    /* Set off UART baud doubler */
+    UCSR1A &= ~(1 << U2X1);
+
+    /* Enable transmitter & receiver with interrupts */
+    UCSR1B = (1 << RXCIE1 | 1 << TXEN1 | 1 << RXEN1);
+
+    /* Set 8 bits character and 1 stop bit */
+    UCSR1C = (1 << UCSZ11 | 1 << UCSZ10);
+
+    for (int i = 0; i < 256; i++) {
+        rxHandlersAF[i] = NULL;
+    }
+    sSendAF = xSemaphoreCreateMutex();
+    xTaskCreate(TaskReaderAF, "TaskReaderAF", 128, NULL, 2, &tReaderAF);
+}

arduino/AF.h

@@ -0,0 +1,35 @@
+/*
+ * Définition des fonctions utilisées pour échager entre l'Arduino et le chef
+ */
+
+#ifndef __AF_H_
+#define __AF_H_
+
+#include <FreeRTOS.h>
+#include <avr/interrupt.h>
+#include <avr/io.h>
+#include <queue.h>
+#include <semphr.h>
+#include <stdlib.h>
+#include <task.h>
+#include "AFsignals.h"
+
+#define CPU_FREQ 16000000UL
+#define AF_PRESCALER CPU_FREQ / (AF_BAUDRATE << 4) - 1
+
+TaskHandle_t tReaderAF;
+SemaphoreHandle_t sSendAF;
+unsigned char* toSendAF;
+size_t toSendSizeAF;
+
+typedef void (*rxHandler)(void);
+rxHandler rxHandlersAF[256];
+
+void registerRxHandlerAF(unsigned char code, rxHandler handler); // À utiliser après configureAF();
+void sendAF(unsigned char code, void* data, size_t size);
+unsigned char readByteAF(); // À utiliser uniquement depuis un rxHandler
+void readAF(void* data, size_t size); // À utiliser uniquement depuis un rxHandler
+void TaskReaderAF(void* pvParameters); // Privé
+void configureAF();
+
+#endif

arduino/AFsignals.h

@@ -0,0 +1,67 @@
+/*
+ * Définition des signaux échagés entre l'Arduino et le chef
+ */
+
+#ifndef __AFSIGNALS_H_
+#define __AFSIGNALS_H_
+
+#include <stdint.h>
+
+#define AF_BAUDRATE 9600UL
+
+// Structures used everywhere
+
+// D: Direct
+// Sens naturel : Envoi de donnée
+// Sens inverse : Accusé de réception
+
+// I: Indirect
+// Sens inverse : Demande de donnée
+// Sens naturel : Envoi de donnée
+
+// T: Trigger
+// Sens inverse : Paramètrage du trigger
+// Sens naturel : Envoi de trigger
+
+// Arduino → FPGA
+
+// Pour le debug
+#define A2FD_PING 'P'
+
+// Réinitialise la valeur des codeuses
+#define A2FD_RESETCODER 'R'
+
+// FPGA → Arduino
+
+// Erreur quelconque
+#define F2AD_ERR 'E'
+struct __attribute__ ((packed)) F2AD_ERRs {
+    unsigned char code;
+};
+
+#define ERR_UNKNOWN_CODE 'C'
+
+// Récupère les valeur des encodeurs
+#define F2AI_CODER 'D'
+struct __attribute__ ((packed)) F2AI_CODERs {
+    int16_t left;
+    int16_t right;
+};
+
+// Récupère les valeur des capteurs de distance
+#define F2AI_CAPT 'C'
+struct __attribute__ ((packed)) F2AI_CAPTs {
+    uint16_t front;
+    uint16_t back;
+};
+
+// Récupère les valeur des capteurs de distance (trigger au supérieur)
+#define F2AT_CAPT 'c'
+// /!\ Structure de la requête de trigger (A→F). Les données seront envoyées avec F2AI_CAPT 
+struct __attribute__ ((packed)) F2AT_CAPTs { 
+    uint16_t front;
+    uint16_t back;
+};
+
+
+#endif

arduino/FreeRTOSConfig.h

@@ -85,13 +85,6 @@
 #define INCLUDE_xQueueGetMutexHolder    1
 // -- done
 
-// JF: added
-#define configUSE_TIMERS                        1
-#define configTIMER_TASK_PRIORITY               3
-#define configTIMER_QUEUE_LENGTH                10
-#define configTIMER_TASK_STACK_DEPTH            configMINIMAL_STACK_SIZE
-// -- done
-
 #define configUSE_PREEMPTION		1
 #define configUSE_IDLE_HOOK			0
 #define configUSE_TICK_HOOK			0

arduino/Makefile

@@ -29,7 +29,7 @@ FORMAT = ihex
 
 # Target file name (without extension).
 TARGET = principal
-OBJS = AC position movement debug
+OBJS = AC AF position movement debug
 
 # Custom
 NAME = $(TARGET).c
@@ -78,7 +78,7 @@ LDFLAGS = -Wl,-Map=$(TARGET).map,--cref
 # Type: avrdude -c ?
 # to get a full listing.
 #
-AVRDUDE_PROGRAMMER = stk500
+AVRDUDE_PROGRAMMER = wiring
 
 AVRDUDE_PORT = /dev/ttyACM0	   # programmer connected to serial device
 

arduino/debug.c

@@ -8,7 +8,7 @@
 void TaskDebug(void *pvParameters) {
     (void) pvParameters;
     for (;;) {
-        vTaskSuspend(tDebug);
+        ulTaskNotifyTake(pdFALSE, portMAX_DELAY);
 
         // Copie des valeurs à envoyer en debug
         memcpy((void*) &debug.actuel, (const void*) &actuel, (unsigned long) sizeof(actuel));
@@ -21,12 +21,12 @@ void TaskDebug(void *pvParameters) {
 }
 
 void onA2CI_DBG() {
-    vTaskResume(tDebug);
+    vTaskNotifyGiveFromISR(tDebug, NULL);
 }
 
 
 void configureDebug() {
-    registerRxHandler(A2CI_DBG, onA2CI_DBG);
+    registerRxHandlerAC(A2CI_DBG, onA2CI_DBG);
     xTaskCreate(TaskDebug, "Debug", 128, NULL, 10, &tDebug);;
 }
 

arduino/movement.c

@@ -1,4 +1,5 @@
 #include "movement.h"
+#include "position.h"
 #include "AC.h"
 
 void TaskMovement(void *pvParameters) {
@@ -6,19 +7,25 @@ void TaskMovement(void *pvParameters) {
     TickType_t xLastWakeTime;
     TickType_t xFrequency = 100 / portTICK_PERIOD_MS;
 
-    vTaskSuspend(tMovement); // Mettre en veille jusqu'à l'arrivée de la prochaine instruction
+    ulTaskNotifyTake(pdFALSE, portMAX_DELAY); // Mettre en veille jusqu'à l'arrivée de la prochaine instruction
     xLastWakeTime = xTaskGetTickCount();
     for (;;) {
 
         // TODO Ici ira le code qui changera les valeurs des moteurs
         vTaskDelayUntil(&xLastWakeTime, 1000 / portTICK_PERIOD_MS);
 
+        if (movement == C2AD_GOTO) {
+            actuel.x = destination.x;
+            actuel.y = destination.y;
+            actuel.o = destination.o;
+        }
+
         if (true) { // Arrivé à destination
             sendAC(movement, NULL, 0); // On rapporte au chef qu'on a terminé l'action en cours
-            // Mettre en brake
+            // TODO Mettre en brake
+            movement = C2AD_STOP;
 
-            // Envoi du message de bonne réception
-            vTaskSuspend(tMovement); // Mettre en veille jusqu'à l'arrivée de la prochaine instruction
+            ulTaskNotifyTake(pdFALSE, portMAX_DELAY); // Mettre en veille jusqu'à l'arrivée de la prochaine instruction
             xLastWakeTime = xTaskGetTickCount();
         } else {
             vTaskDelayUntil(&xLastWakeTime, xFrequency);
@@ -28,13 +35,13 @@ void TaskMovement(void *pvParameters) {
 
 void onC2AD_STOP() {
     movement = C2AD_STOP;
-    vTaskResume(tMovement);
+    vTaskNotifyGiveFromISR(tMovement, NULL);
 }
 
 void onC2AD_GOTO() {
     movement = C2AD_GOTO;
     readAC(&destination, sizeof(struct C2AD_GOTOs));
-    vTaskResume(tMovement);
+    vTaskNotifyGiveFromISR(tMovement, NULL);
 }
 
 
@@ -43,8 +50,8 @@ void configureMovement() {
 
     movement = C2AD_STOP;
 
-    registerRxHandler(C2AD_STOP, onC2AD_STOP);
-    registerRxHandler(C2AD_GOTO, onC2AD_GOTO);
+    registerRxHandlerAC(C2AD_STOP, onC2AD_STOP);
+    registerRxHandlerAC(C2AD_GOTO, onC2AD_GOTO);
 
     xTaskCreate(TaskMovement, "Movement", 128, NULL, 2, &tMovement);;
 }

arduino/position.c

@@ -6,7 +6,7 @@ void TaskPosition(void *pvParameters) {
     TickType_t xLastWakeTime;
     TickType_t xFrequency = 100 / portTICK_PERIOD_MS;
 
-    vTaskSuspend(tPosition); // TODO Dummy
+    ulTaskNotifyTake(pdFALSE, portMAX_DELAY); // TODO Dummy
     xLastWakeTime = xTaskGetTickCount();
     for (;;) {
         vTaskDelayUntil(&xLastWakeTime, xFrequency);
@@ -16,6 +16,10 @@ void TaskPosition(void *pvParameters) {
 
 
 void configurePosition() {
+    actuel.x = 0;
+    actuel.y = 0;
+    actuel.o = 90;
+
     xTaskCreate(TaskPosition, "Position", 128, NULL, 2, &tPosition);;
 }
 

arduino/principal.c

@@ -4,16 +4,15 @@
 #include <task.h>
 
 #include "AC.h"
+#include "AF.h"
 #include "position.h"
 #include "movement.h"
 #include "debug.h"
 
-unsigned char speed = 200;
-
 void TaskBlink(void *pvParameters) {
     (void) pvParameters;
     TickType_t xLastWakeTime;
-    TickType_t xFrequency = speed / portTICK_PERIOD_MS;
+    TickType_t xFrequency = 200 / portTICK_PERIOD_MS;
 
     DDRB = 0xFF;
 
@@ -26,6 +25,7 @@ void TaskBlink(void *pvParameters) {
 
 int main(void) {
     configureAC(); // Doit rester en premier :)
+    configureAF(); // Doit rester en premier :)
     configureMovement();
     configurePosition();
     configureDebug();