Keuronde/2026-USB-Maitre
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Préparation pour expédier des messages

Browse Source
This commit is contained in:
Samuel 2025-09-13 15:35:50 +02:00
parent 320b5eaf04
commit 8c763b1e67
6 changed files with 132 additions and 84 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
.vscode/settings.json vendored
View File

@ -14,6 +14,7 @@
"sd_card.h": "c",
"rp2040_sdio.h": "c",
"util.h": "c",
"stddef.h": "c"
"stddef.h": "c",
"log_usb.h": "c"
}
}

51
cdc_app.c
View File

@ -45,6 +45,51 @@ size_t get_console_inputs(uint8_t* buf, size_t bufsize) {
return count;
}
void traiter_les_messages(uint8_t idx, struct message_t message){
// Debug
char message_en_clair[1024];
message_to_string(message, message_en_clair);
printf("%s\n", message_en_clair);
if(message.type == 'r'){
// Reception de données
// Si les données contiennent le registre 0, nous obtenons l'identifiant de la carte
// 'D' pour la carte de détection
if(message.adresse_registre == 0){
set_carte_id(idx, message.donnees[0]);
}
struct log_buffer_t * log_buffer = get_buffer(idx);
for(int i=0; i<message.taille_donnees; i++){
log_buffer->tampon_echange[message.adresse_registre + i] = message.donnees[i];
}
}
if(message.type == 'd'){
struct message_t message_emis;
char message_binaire[64];
uint32_t taille_message;
// Demande de données
uint8_t idx_destination = get_carte_idx(message.id_carte);
if(idx_destination == INVALID_ID){
panic("no idx found\n"); // Return est peut-être suffisant
return;
}
struct log_buffer_t * log_buffer = get_buffer(idx_destination);
message_emis.type = 'r';
message_emis.adresse_registre = message.adresse_registre;
message_emis.taille_donnees = message.taille_donnees;
memcpy(message_emis.donnees, &(log_buffer->tampon_echange[message.adresse_registre]), message.taille_donnees);
taille_message = message_prepare_for_usb(message_emis, message_binaire);
tuh_cdc_write(idx_destination, message_binaire, taille_message);
}
}
void cdc_app_task(void) {
uint8_t buf[64 + 1]; // +1 for extra null character
uint32_t const bufsize = sizeof(buf) - 1;
@ -68,16 +113,14 @@ void cdc_app_task(void) {
if (tuh_cdc_mounted(idx)) {
struct message_t message;
char chaine[1024];
char message_en_clair[1024];
char texte_log[255];
unsigned int position_chaine = 0, position_sous_chaine;
log_analyse(idx);
while(message_disponible()){
message = get_message();
// Debug
message_to_string(message, message_en_clair);
printf("%s\n", message_en_clair);
traiter_les_messages(idx, message);
}
}

36
log_usb.c
View File

@ -2,21 +2,36 @@
#include "pico/platform/panic.h"
#include "pico/stdlib.h"
#include "messagerie.h"
#include "log_usb.h"
#include <stdio.h>
#define NB_MAX_CDC_CONNEXION 10
#define TAMPON_TAILLE 1020
#define INVALID_ID ((char)-1)
struct log_buffer_t{
char idx;
char tampon[TAMPON_TAILLE]; // Tampon tournant - 1er niveau de tampon
unsigned int index_tampon_ecriture, index_tampon_lecture;
}log_buffer[NB_MAX_CDC_CONNEXION];
struct log_buffer_t log_buffer[NB_MAX_CDC_CONNEXION];
static struct log_buffer_t * get_buffer(const char idx);
/// @brief Affecte l'id de la carte à une connexion CDC.
/// @param idx
/// @param carte_id
void set_carte_id(uint8_t idx, uint8_t carte_id){
struct log_buffer_t * p_log_bufffer;
p_log_bufffer = get_buffer(idx);
p_log_bufffer->carte_id = carte_id;
}
static struct log_buffer_t * get_buffer(const char idx){
/// @brief Obtient la connexion CDC à partir de l'id de la carte.
/// @param id_carte
/// @return idx pour établir la connexion CDC, INVALID_ID si non trouvé.
uint8_t get_carte_idx(uint8_t id_carte){
for(int i=0; i<NB_MAX_CDC_CONNEXION; i++){
if(log_buffer[i].carte_id == id_carte){
return log_buffer[i].idx;
}
}
return INVALID_ID;
}
struct log_buffer_t * get_buffer(const char idx){
for (int i=0; i<NB_MAX_CDC_CONNEXION; i++){
if(log_buffer[i].idx == idx){
return &(log_buffer[i]);
@ -42,6 +57,7 @@ void log_create(const char idx){
for (int i=0; i<NB_MAX_CDC_CONNEXION; i++){
if(log_buffer[i].idx == INVALID_ID){
log_buffer[i].idx = idx;
log_buffer[i].carte_id = INVALID_ID;
log_buffer[i].index_tampon_ecriture = 0;
log_buffer[i].index_tampon_lecture = 0;
return;
@ -155,7 +171,7 @@ void log_analyse(const char idx){
}
if(chaine[i] == 'r'){
// Est-ce que nous avons reçu l'entête du message ?
if(i + 3 < index_chaine){
if(i + 4 < index_chaine){
message.type = 'r';
message.adresse_registre = chaine[i+1];
message.taille_donnees = chaine[i+2];

17
log_usb.h
View File

@ -1,8 +1,21 @@
#define TAMPON_TAILLE 1020
#define NB_MAX_CDC_CONNEXION 10
#define INVALID_ID ((char)-1)
struct log_buffer_t{
char idx;
char carte_id;
char tampon[TAMPON_TAILLE]; // Tampon tournant - 1er niveau de tampon
char tampon_echange[TAMPON_TAILLE]; // Tampon contenant l'état de la carte
unsigned int index_tampon_ecriture, index_tampon_lecture;
};
void log_init(void);
void log_create(const char idx);
void log_destroy(const char idx);
void log_analyse_input_string(const char idx, char * input_data, unsigned int str_len);
void log_get(const char idx, char * chaine);
void log_analyse(const char idx);
void log_add(const char idx, const char * buffer, uint16_t buffer_size);
struct log_buffer_t * get_buffer(const char idx);
void set_carte_id(uint8_t idx, uint8_t carte_id);
uint8_t get_carte_idx(uint8_t id_carte);

102
messagerie.c
View File

@ -64,73 +64,47 @@ char message_to_string(struct message_t message, char * chaine_texte){
}
/// @brief remplit la mémoire message_binaire pour les données du message en usb
/// @param message
/// @param message_binaire
/// @return nombre d'octet à envoyer
uint16_t message_prepare_for_usb(struct message_t message, uint8_t * message_binaire){
switch (message.type)
{
case 'r':
message_binaire[0] = message.type;
message_binaire[1] = message.adresse_registre;
message_binaire[2] = message.taille_donnees;
for(int i=0; i < message.taille_donnees; i++){
message_binaire[3+i] = message.donnees[i];
}
message_binaire[3+message.taille_donnees] = 0;
struct message_t messagerie_read_message(const char * chaine, unsigned int * position_chaine){
struct message_t message;
unsigned int position_sous_chaine;
message.type = 0;
return (3 + message.taille_donnees);
break;
switch(chaine[*position_chaine]){
case '>':
// copier les données tant qu'on ne trouve pas un retour à la ligne ou de fin de chaine
position_sous_chaine = 0;
message.type = '>';
while(*position_chaine + position_sous_chaine < 1024 && position_sous_chaine < 254){
message.donnees[position_sous_chaine] = chaine[*position_chaine + position_sous_chaine];
case 'd':
message_binaire[0] = message.type;
message_binaire[1] = message.id_carte;
message_binaire[2] = message.adresse_registre;
message_binaire[3] = message.taille_donnees;
message_binaire[4] = 0;
return 5;
if(message.donnees[position_sous_chaine] == '\n' || message.donnees[position_sous_chaine] == '\0'){
break;
}
position_sous_chaine++;
}
if(message.donnees[position_sous_chaine-1] != '\0'){
message.donnees[position_sous_chaine] == '\0';
}
*position_chaine = *position_chaine + position_sous_chaine;
break;
case 'w':
message_binaire[0] = message.type;
message_binaire[1] = message.id_carte;
message_binaire[2] = message.adresse_registre;
message_binaire[3] = message.taille_donnees;
for(int i=0; i < message.taille_donnees; i++){
message_binaire[4+i] = message.donnees[i];
}
message_binaire[4+message.taille_donnees] = 0;
return (4 + message.taille_donnees);
case 'd':
if(*position_chaine + 4 < 1024){
if(chaine[*position_chaine + 4] == '\0'){
message.type = chaine[*position_chaine];
message.id_carte = chaine[*position_chaine + 1];
message.adresse_registre = chaine[*position_chaine + 2];
message.taille_donnees = chaine[*position_chaine + 3];
}
default:
break;
}
}
case 'r':
if(*position_chaine + 2 < 1024){
// Read size
message.taille_donnees = chaine[*position_chaine + 2];
position_sous_chaine = 2 + message.taille_donnees + 1;
if(*position_chaine + position_sous_chaine < 1024){
if(chaine[*position_chaine + position_sous_chaine] == '\0'){
message.type = chaine[*position_chaine];
message.adresse_registre = chaine[*position_chaine + 1];
message.taille_donnees = chaine[*position_chaine + 2]; // déjà fait plus haut
memcpy(message.donnees, &(chaine[*position_chaine + 3]), message.taille_donnees);
}
}
}
break;
case 'w':
if(*position_chaine + 3 < 1024){
// Read size
message.taille_donnees = chaine[*position_chaine + 3];
position_sous_chaine = 3 + message.taille_donnees + 1;
if(*position_chaine + position_sous_chaine < 1024){
if(chaine[*position_chaine + position_sous_chaine] == '\0'){
message.type = chaine[*position_chaine];
message.id_carte = chaine[*position_chaine + 1];
message.adresse_registre = chaine[*position_chaine + 2];
message.taille_donnees = chaine[*position_chaine + 3]; // déjà fait plus haut
memcpy(message.donnees, &(chaine[*position_chaine + 4]), message.taille_donnees);
}
}
}
default:
}
}

1
messagerie.h
View File

@ -11,6 +11,7 @@ struct message_t{
struct message_t messagerie_read_message(const char * chaine, unsigned int * position_chaine);
char message_to_string(struct message_t message, char * chaine_texte);
uint16_t message_prepare_for_usb(struct message_t message, uint8_t * message_binaire);
bool message_disponible(void);
void put_message(struct message_t message);