249 lines
8.3 KiB
C
249 lines
8.3 KiB
C
#include <string.h>
|
|
#include "pico/platform/panic.h"
|
|
#include "pico/stdlib.h"
|
|
#include "messagerie.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 copy_active;
|
|
char tampon[TAMPON_TAILLE]; // Tampon tournant - 1er niveau de tampon
|
|
char log_dispo[TAMPON_TAILLE]; //
|
|
unsigned int index_tampon;
|
|
unsigned int index_tampon_ecriture, index_tampon_lecture;
|
|
}log_buffer[10];
|
|
|
|
static struct log_buffer_t * get_buffer(const char idx);
|
|
|
|
static 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]);
|
|
}
|
|
}
|
|
/// TODO: panic ?
|
|
panic("Buffer IDX not found: %d\n", idx);
|
|
return NULL;
|
|
}
|
|
|
|
/// @brief Initialisation des structure de reception des données USB-CDC
|
|
void log_init(){
|
|
for (int i=0; i<NB_MAX_CDC_CONNEXION; i++){
|
|
log_buffer[i].log_dispo[0] = '\0';
|
|
log_buffer[i].index_tampon = 0;
|
|
log_buffer[i].copy_active = 0;
|
|
log_buffer[i].idx = INVALID_ID;
|
|
log_buffer[i].index_tampon = 0;
|
|
log_buffer[i].index_tampon_ecriture = 0;
|
|
log_buffer[i].index_tampon_lecture = 0;
|
|
}
|
|
}
|
|
|
|
/// @brief Affectation des tampons de reception à une liaison USB-CDC
|
|
/// @param idx :
|
|
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;
|
|
return;
|
|
}
|
|
}
|
|
panic("Creation impossible: idx: %d\n", idx);
|
|
}
|
|
|
|
void log_destroy(const char idx){
|
|
struct log_buffer_t * p_log_bufffer;
|
|
p_log_bufffer = get_buffer(idx);
|
|
p_log_bufffer->idx = INVALID_ID;
|
|
}
|
|
|
|
/// @brief Ajoute les données reçu au tampon tournant
|
|
/// @param idx Numéro de la liaison CDC
|
|
/// @param buffer Pointeur vers les données
|
|
/// @param buffer_size Taille des données
|
|
void log_add(const char idx, const char * buffer, uint16_t buffer_size){
|
|
struct log_buffer_t * log_buffer;
|
|
log_buffer = get_buffer(idx);
|
|
|
|
for(int i=0; i<buffer_size; i++){
|
|
log_buffer->index_tampon_ecriture = log_buffer->index_tampon_ecriture+1;
|
|
if(log_buffer->index_tampon_ecriture >= TAMPON_TAILLE){
|
|
log_buffer->index_tampon_ecriture = 0;
|
|
}
|
|
log_buffer->tampon[log_buffer->index_tampon_ecriture] = buffer[i];
|
|
}
|
|
}
|
|
|
|
/// @brief Incrémente l'index du tampon tournant
|
|
/// @param index
|
|
/// @return
|
|
void increment_index(unsigned int *index){
|
|
*index = 1 + *index ;
|
|
if((*index) >= TAMPON_TAILLE){
|
|
*index = 0;
|
|
}
|
|
}
|
|
|
|
/// @brief augmente la position l'index du tampon tournant
|
|
/// @param index
|
|
/// @return
|
|
void augmente_index(unsigned int *index, unsigned int offset){
|
|
*index = offset + *index ;
|
|
if((*index) >= TAMPON_TAILLE){
|
|
*index -= TAMPON_TAILLE;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
void log_analyse(const char idx){
|
|
// Les données sont dans le tampon tournant
|
|
// Nous les copions dans une seconde mémoire pour les analyser.
|
|
// Si un message est trouvé :
|
|
// - Celui-ci est ajouté à la liste des message à traiter
|
|
// - Nous avançons l'index de lecture du tampon cyclique
|
|
// Si nous arrivons à la fin du tampon cyclique, il n'y a plus rien à récupérer.
|
|
enum etat_message_t{
|
|
ETAT_MESSAGE_DEBUT,
|
|
ETAT_MESSAGE_TEXTE,
|
|
ETAT_MESSAGE_VALIDE
|
|
}etat_message;
|
|
|
|
struct log_buffer_t * p_log_bufffer;
|
|
char chaine[TAMPON_TAILLE];
|
|
char affiche_message[TAMPON_TAILLE];
|
|
struct message_t message;
|
|
|
|
unsigned int index, index_chaine;
|
|
p_log_bufffer = get_buffer(idx);
|
|
|
|
index = p_log_bufffer->index_tampon_lecture;
|
|
index_chaine = 0;
|
|
|
|
// Copie des données
|
|
do{
|
|
chaine[index_chaine] = p_log_bufffer->tampon[index];
|
|
index_chaine++;
|
|
increment_index(&index);
|
|
}while(index != log_buffer->index_tampon_ecriture);
|
|
|
|
|
|
// Lecture du message
|
|
message.type = 0;
|
|
unsigned int fin_message = 0;
|
|
for(int i=0; i< index_chaine; i++){
|
|
char index_fin_message;
|
|
switch(etat_message){
|
|
case ETAT_MESSAGE_DEBUT:
|
|
if(chaine[i] == '>'){
|
|
message.type = '>';
|
|
message.taille_donnees = 0;
|
|
etat_message = ETAT_MESSAGE_TEXTE;
|
|
}
|
|
if(chaine[i] == 'd'){
|
|
// Est-ce que nous avons reçu le message en entier ?
|
|
if(i + 4 < index_chaine){
|
|
if(chaine[i+4] == 0){
|
|
// Message valide
|
|
message.type = 'd';
|
|
message.id_carte = chaine[i+1];
|
|
message.adresse_registre = chaine[i+2];
|
|
message.taille_donnees = chaine[i+3];
|
|
i = i + 4; // On se met à la fin du message
|
|
fin_message = i;
|
|
// Debug
|
|
message_to_string(message, affiche_message);
|
|
printf("%s\n", affiche_message);
|
|
|
|
}
|
|
}
|
|
}
|
|
if(chaine[i] == 'r'){
|
|
// Est-ce que nous avons reçu l'entête du message ?
|
|
if(i + 3 < index_chaine){
|
|
message.type = 'd';
|
|
message.adresse_registre = chaine[i+1];
|
|
message.taille_donnees = chaine[i+2];
|
|
index_fin_message = i+ message.taille_donnees + 3;
|
|
if(index_fin_message < index_chaine){
|
|
if(chaine[index_fin_message] == 0){
|
|
// Message valide
|
|
for(int j=i+3; j<index_fin_message; j++){
|
|
message.donnees[j - (i+3)] = chaine[j];
|
|
}
|
|
i = i + index_fin_message; // On se met à la fin du message
|
|
fin_message = index_fin_message;
|
|
etat_message = ETAT_MESSAGE_DEBUT;
|
|
// Debug
|
|
message_to_string(message, affiche_message);
|
|
printf("%s\n", affiche_message);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case ETAT_MESSAGE_TEXTE:
|
|
message.donnees[message.taille_donnees] = chaine[i];
|
|
message.taille_donnees++;
|
|
if(chaine[i] == '\n'){
|
|
// message valide.
|
|
message.donnees[message.taille_donnees] = '\0';
|
|
fin_message = i;
|
|
message_to_string(message, affiche_message);
|
|
|
|
printf("%s\n", affiche_message);
|
|
etat_message = ETAT_MESSAGE_DEBUT;
|
|
}
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
augmente_index(&(p_log_bufffer->index_tampon_lecture), fin_message);
|
|
}
|
|
|
|
void log_analyse_input_string(const char idx, const char * input_data, unsigned int str_len){
|
|
// On charge les données dans le tampon
|
|
// Si on a un message complet, on charge dans log dispo (s'il y a la place)
|
|
struct log_buffer_t * p_log_bufffer;
|
|
p_log_bufffer = get_buffer(idx);
|
|
for(int i=0; i< str_len; i++){
|
|
if(input_data[i] == '>'){
|
|
p_log_bufffer->copy_active = 1;
|
|
}
|
|
if(p_log_bufffer->copy_active == 1){
|
|
p_log_bufffer->tampon[p_log_bufffer->index_tampon] = input_data[i];
|
|
p_log_bufffer->index_tampon++;
|
|
|
|
if(input_data[i] == '\n'){
|
|
p_log_bufffer->copy_active = 0;
|
|
p_log_bufffer->tampon[p_log_bufffer->index_tampon] = '\0';
|
|
strcat(p_log_bufffer->log_dispo, p_log_bufffer->tampon);
|
|
p_log_bufffer->index_tampon=0;
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
// On renvoi la chaine et on remet log_dispo à 0;
|
|
void log_get(const char idx, char * chaine){
|
|
struct log_buffer_t * p_log_bufffer;
|
|
p_log_bufffer = get_buffer(idx);
|
|
if(p_log_bufffer == NULL){
|
|
chaine[0] = '\0';
|
|
return;
|
|
}
|
|
|
|
strcpy(chaine, p_log_bufffer->log_dispo);
|
|
p_log_bufffer->log_dispo[0] = '\0';
|
|
}
|
|
|
|
|