549 lines
23 KiB
C
549 lines
23 KiB
C
//**********************************************************************************************************************************************************************************
|
|
// Fichier C_BUS.C
|
|
//
|
|
// Contient toutes les fonctions liées à la gestion du C_Bus
|
|
//**********************************************************************************************************************************************************************************/
|
|
|
|
|
|
#define __DEBUG_C_BUS 0 // Passer cette ligne à 0: aucun message de debug de C_bus, 1: les messages de debug de C_Bus sur l'écran, 2: sur fichier (cf NOM_FICHIER_DEBUG_BUS dans 'debug.h') ou 3: sur l'écran et fichier.
|
|
|
|
// Includes :
|
|
#include "main.h"
|
|
|
|
// Prototypes :
|
|
int8_t init_c_bus(void);
|
|
void gestion_c_bus(void);
|
|
int8_t gestion_protocole_rx_c_bus(void);
|
|
void gestion_protocole_tx_c_bus(void);
|
|
int8_t c_bus_next_write_buffer_cdes(uint8_t priorite);
|
|
|
|
// Variables globales :
|
|
struct Struct_c_bus c_bus;
|
|
|
|
|
|
/**********************************************************************************************************************************************************************************
|
|
Fonction INIT_C_BUS
|
|
|
|
Fonction d'initialisation du C-Bus
|
|
**********************************************************************************************************************************************************************************/
|
|
int8_t init_c_bus(void)
|
|
{
|
|
//------------------------------------------------------------------------------------------------------
|
|
// Init des variables générales :
|
|
|
|
c_bus.sequenceur.etat = ETAT_SEQUENCEUR_C_BUS_INIT;
|
|
c_bus.sequenceur.compteur = C_BUS_TEMPO_INIT;
|
|
c_bus.protocole_rx.sequenceur.etat = ETAT_SEQUENCEUR_C_BUS_PROTOCOLE_RX_INIT;
|
|
c_bus.protocole_rx.sequenceur.compteur = C_BUS_PROTOCOLE_RX_TEMPO_INIT;
|
|
c_bus.protocole_rx.flag_dle = FALSE;
|
|
|
|
c_bus.protocole_tx.sequenceur.etat = ETAT_SEQUENCEUR_C_BUS_PROTOCOLE_TX_INIT;
|
|
c_bus.protocole_tx.sequenceur.compteur = C_BUS_PROTOCOLE_TX_TEMPO_INIT;
|
|
|
|
|
|
|
|
// Affichage du message de débug :
|
|
affichage_debug(__FILE__, __LINE__, "Initialisation du C-BUS\t\t: OK", TYPE_MESSAGE_DEBUG_OK);
|
|
return(0);
|
|
}
|
|
|
|
|
|
|
|
/**********************************************************************************************************************************************************************************
|
|
Fonction GESTION_C_BUS
|
|
|
|
Fonction de plus haut niveau de gestion du C-Bus
|
|
**********************************************************************************************************************************************************************************/
|
|
void gestion_c_bus(void)
|
|
{
|
|
char tmp[MAX_LONGUEUR_BUFFER_TEMPORAIRE_DEBUG];
|
|
|
|
|
|
switch(c_bus.sequenceur.etat)
|
|
{
|
|
//--------------------------------------------------------
|
|
case ETAT_SEQUENCEUR_C_BUS_INIT :
|
|
{
|
|
if (c_bus.sequenceur.compteur == 0)
|
|
{
|
|
//.........................................................
|
|
// Vidage du buffer de réception de tous les caractères reçus pendant la phase d'init :
|
|
serial1.ptr_debut_buffer_rx = 0;
|
|
serial1.ptr_fin_buffer_rx = 0;
|
|
|
|
//.........................................................
|
|
// Mise à jour des séquenceurs pour démarrage des envois :
|
|
c_bus.protocole_rx.sequenceur.compteur = 0;
|
|
c_bus.protocole_rx.sequenceur.etat = ETAT_SEQUENCEUR_C_BUS_PROTOCOLE_RX_REPOS;
|
|
c_bus.protocole_tx.sequenceur.compteur = 0;
|
|
c_bus.protocole_tx.sequenceur.etat = ETAT_SEQUENCEUR_C_BUS_PROTOCOLE_TX_REPOS;
|
|
c_bus.sequenceur.etat = ETAT_SEQUENCEUR_C_BUS_REPOS;
|
|
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
//--------------------------------------------------------
|
|
case ETAT_SEQUENCEUR_C_BUS_REPOS :
|
|
{
|
|
//=================================
|
|
// Gestion du C-Bus en émission :
|
|
|
|
gestion_protocole_tx_c_bus(); // Vérifie si une réponse (Up) ou une commande (Down) est en attente. Si oui, elle la traite et l'émet.
|
|
|
|
|
|
//=================================
|
|
// Gestion du C-Bus en réception :
|
|
|
|
if (gestion_protocole_rx_c_bus() == 1) // Vérifie si une commande (Up) ou une réponse (Down) a été reçue.
|
|
{
|
|
|
|
#ifdef __DEBUG_C_BUS
|
|
c_bus.down.reponse.reponse[c_bus.down.reponse.lg_reponse] = 0; // On ajoute un /0 à la fin mais on ne change surtout pas la longueur qui est utilisée pour les transferts binaires.
|
|
affichage_debug_bus(TYPE_BUS_DEBUG_C_BUS, "Rx", (char *) c_bus.down.reponse.reponse, __DEBUG_C_BUS);
|
|
#endif
|
|
if (c_bus.protocole_rx.sens == 'U') // Réception d'une commande (Up) :
|
|
{
|
|
c_bus_up_recherche_commande(); // Recherche et traitement de la commande reçue. La réponse est préparée et son 'flag_ready' est positionné afin d'être traité par gestion_protocole_tx_c_bus() lors de la prochaine boucle.
|
|
}
|
|
else // Réception d'une réponse (Down) :
|
|
{
|
|
if (c_bus_down_recherche_reponse() != -1) // Comme la réponse a été reçue sans erreur, on libère le Protocole_Tx :
|
|
{
|
|
c_bus.down.flag_attente_reponse = FALSE;
|
|
c_bus.protocole_tx.repetitions = 0;
|
|
c_bus.protocole_tx.sequenceur.compteur_time_out = 0;
|
|
}
|
|
else c_bus.protocole_tx.sequenceur.compteur_time_out = 0; // En cas de réponse reçue avec erreur, on simule un déclenchement de time-out pour faire de suite le test du nombre de répétitions (cela permet juste de ne pas attandre l'expiration du time-out)
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------
|
|
default :
|
|
{
|
|
sprintf(tmp, "L'état du séquenceur C_bus est inconnu [%i]. Il est repositionné au REPOS", c_bus.sequenceur.etat);
|
|
affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_ERREUR);
|
|
c_bus.sequenceur.etat = ETAT_SEQUENCEUR_C_BUS_REPOS;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*****************************************************************************************************************************************************************
|
|
Fonction : Appelée en tâche de fond, cette fonction lit le buffer de réception de l'UART 1 et traite les trames reçues.
|
|
Soit une commande du Compagnon (Up), soit une réponse à une commande du CM3+ (Down)
|
|
Reçoit : Rien
|
|
Renvoit : 0 si RAS, 1 si une nouvelle commande complète a été reçue
|
|
******************************************************************************************************************************************************************/
|
|
int8_t gestion_protocole_rx_c_bus(void)
|
|
{
|
|
uint8_t c;
|
|
bool flag_controle;
|
|
bool flag_cde_recue;
|
|
char tmp[MAX_LONGUEUR_BUFFER_TEMPORAIRE_DEBUG];
|
|
|
|
|
|
flag_cde_recue = FALSE;
|
|
|
|
// Traitement de chaque caractère reçu :
|
|
while (serial1.ptr_debut_buffer_rx != serial1.ptr_fin_buffer_rx)
|
|
{
|
|
// Calcul de la prochaine position à lire (avec bouclage en fin de buffer tournant) :
|
|
if (++ serial1.ptr_debut_buffer_rx == MAX_TAILLE_RX_BUFFER_UART) serial1.ptr_debut_buffer_rx = 0;
|
|
|
|
// Lecture du caractère dans le buffer :
|
|
flag_controle = FALSE; // Permettra de marquer le caractère en cours de lecture
|
|
c = serial1.buffer_rx[serial1.ptr_debut_buffer_rx]; // Lecture du caractère à traiter
|
|
|
|
|
|
// Traitement des caractères DLE :
|
|
if (c_bus.protocole_rx.flag_dle == TRUE) // Si le caractère précédent était un DLE
|
|
{
|
|
switch(c)
|
|
{
|
|
case ASCII_DLE : break; // C'est un DLE qui a fort justement été doublé, on va donc traiter le second comme un octet de data.
|
|
|
|
case ASCII_SOH : // Caractères de contrôle échappés
|
|
case ASCII_STX :
|
|
case ASCII_ETX :
|
|
{
|
|
flag_controle = TRUE; // On marque donc 'x' comme un caractère de contrôle et non une data
|
|
break;
|
|
}
|
|
|
|
default: // erreur de "DLE isolé"
|
|
{
|
|
flag_controle = TRUE; // On marque donc 'x' comme un caractère de contrôle et non une data
|
|
c = ASCII_NULL; // On change volontairement la valeur à NULL afin que la trame soit rejetée et qu'en fonction de l'état du séquenceur, un NACK soit retourné ou non...
|
|
break;
|
|
}
|
|
}
|
|
|
|
c_bus.protocole_rx.flag_dle = FALSE; // Dans tous les cas précédent, le premier DLE a été traité (y compris dans le cas d'un double DLE)
|
|
}
|
|
else // Si le caractère précédent n'était PAS un DLE :
|
|
{
|
|
if (c == ASCII_DLE) c_bus.protocole_rx.flag_dle = TRUE; // On positionne le flag si c'est un DLE
|
|
}
|
|
|
|
|
|
// Traitement du caractère reçu :
|
|
if (c_bus.protocole_rx.flag_dle == FALSE) // Sauf si on est sur le "premier" DLE...
|
|
{
|
|
switch(c_bus.protocole_rx.sequenceur.etat)
|
|
{
|
|
//------------------------------------------------------------------------------------
|
|
case ETAT_SEQUENCEUR_C_BUS_PROTOCOLE_RX_INIT :
|
|
{
|
|
// NB : Le caractère lu est jeté tant que la phase d'init n'est pas terminée...
|
|
// NB 2 : le passage à l'état REPOS se fait par le séquenceur C-Bus, indépendemment de la réception ou non de caractères.
|
|
break;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------
|
|
case ETAT_SEQUENCEUR_C_BUS_PROTOCOLE_RX_REPOS :
|
|
{
|
|
if ((flag_controle == TRUE) && (c == ASCII_SOH)) // Attente de réception du SOH de début de trame
|
|
{
|
|
c_bus.protocole_rx.cs = (uint16_t) c; // Premier chargement du CS
|
|
c_bus.protocole_rx.sequenceur.etat = ETAT_SEQUENCEUR_C_BUS_PROTOCOLE_RX_SENS;
|
|
}
|
|
break;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------
|
|
case ETAT_SEQUENCEUR_C_BUS_PROTOCOLE_RX_SENS :
|
|
{
|
|
c_bus.protocole_rx.cs += (uint16_t) c; // Rechargement du CS
|
|
|
|
if ((c == 'D') || (c =='U'))
|
|
{
|
|
c_bus.protocole_rx.sens = c;
|
|
|
|
c_bus.protocole_rx.sequenceur.etat = ETAT_SEQUENCEUR_C_BUS_PROTOCOLE_RX_STX;
|
|
}
|
|
else
|
|
{
|
|
#ifdef __DEBUG_C_BUS
|
|
affichage_debug(__FILE__, __LINE__, "Etat séquenceur C-Bus = ETAT_SEQUENCEUR_C_BUS_PROTOCOLE_RX_SENS", TYPE_MESSAGE_DEBUG_WARNING);
|
|
#endif
|
|
c_bus.protocole_rx.sequenceur.etat = ETAT_SEQUENCEUR_C_BUS_PROTOCOLE_RX_ERREUR; // Erreur de CS
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------
|
|
case ETAT_SEQUENCEUR_C_BUS_PROTOCOLE_RX_STX :
|
|
{
|
|
c_bus.protocole_rx.cs += (uint16_t) c; // Rechargement du CS
|
|
|
|
if ((flag_controle == TRUE) && (c == ASCII_STX))
|
|
{
|
|
if (c_bus.protocole_rx.sens == 'U') c_bus.up.cde.lg_cde = 0; // On reçoit une commande Up...
|
|
else c_bus.down.reponse.lg_reponse = 0; // ... ou une réponse à une commande Down
|
|
|
|
c_bus.protocole_rx.sequenceur.etat = ETAT_SEQUENCEUR_C_BUS_PROTOCOLE_RX_DATA;
|
|
|
|
}
|
|
else
|
|
{
|
|
#ifdef __DEBUG_C_BUS
|
|
affichage_debug(__FILE__, __LINE__, "Etat séquenceur C-Bus = ETAT_SEQUENCEUR_C_BUS_PROTOCOLE_RX_STX", TYPE_MESSAGE_DEBUG_WARNING);
|
|
#endif
|
|
c_bus.protocole_rx.sequenceur.etat = ETAT_SEQUENCEUR_C_BUS_PROTOCOLE_RX_ERREUR; // Erreur de CS
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------
|
|
case ETAT_SEQUENCEUR_C_BUS_PROTOCOLE_RX_DATA :
|
|
{
|
|
c_bus.protocole_rx.cs += (uint16_t) c; // Rechargement du CS
|
|
|
|
if (flag_controle == FALSE)
|
|
{
|
|
if (c_bus.protocole_rx.sens == 'U') c_bus.up.cde.cde[c_bus.up.cde.lg_cde ++] = c;
|
|
else c_bus.down.reponse.reponse[c_bus.down.reponse.lg_reponse ++] = c;
|
|
}
|
|
else
|
|
{
|
|
if (c == ASCII_ETX)
|
|
{
|
|
c_bus.protocole_rx.cs_recu = 0;
|
|
c_bus.protocole_rx.ptr_cs_recu = 0;
|
|
c_bus.protocole_rx.sequenceur.etat = ETAT_SEQUENCEUR_C_BUS_PROTOCOLE_RX_CS;
|
|
}
|
|
else
|
|
{
|
|
#ifdef __DEBUG_C_BUS
|
|
affichage_debug(__FILE__, __LINE__, "Etat séquenceur C-Bus = ETAT_SEQUENCEUR_C_BUS_PROTOCOLE_RX_DATA", TYPE_MESSAGE_DEBUG_WARNING);
|
|
#endif
|
|
c_bus.protocole_rx.sequenceur.etat = ETAT_SEQUENCEUR_C_BUS_PROTOCOLE_RX_ERREUR; // Erreur de CS
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------
|
|
case ETAT_SEQUENCEUR_C_BUS_PROTOCOLE_RX_CS :
|
|
{
|
|
if (c_bus.protocole_rx.ptr_cs_recu == 0) // Premier caractère de CS reçu, à archviver en LSB :
|
|
{
|
|
c_bus.protocole_rx.cs_recu = ((uint16_t) c) & 0x00FF;
|
|
c_bus.protocole_rx.ptr_cs_recu ++;
|
|
}
|
|
else // Second caractère de CS reçu, à archiver en MSB puis comparer avec la valeur calculée :
|
|
{
|
|
c_bus.protocole_rx.cs_recu |= (((uint16_t) c) & 0x00FF) << 8;
|
|
if (c_bus.protocole_rx.cs == c_bus.protocole_rx.cs_recu)
|
|
{
|
|
flag_cde_recue = TRUE; // Flag pour remonter qu'une commande a été reçue et sans erreur
|
|
c_bus.protocole_rx.sequenceur.etat = ETAT_SEQUENCEUR_C_BUS_PROTOCOLE_RX_REPOS; // Retour du séquenceur au repos
|
|
}
|
|
else
|
|
{
|
|
#ifdef __DEBUG_C_BUS
|
|
affichage_debug(__FILE__, __LINE__, "Etat séquenceur C-Bus = ETAT_SEQUENCEUR_C_BUS_PROTOCOLE_RX_CS", TYPE_MESSAGE_DEBUG_WARNING);
|
|
#endif
|
|
c_bus.protocole_rx.sequenceur.etat = ETAT_SEQUENCEUR_C_BUS_PROTOCOLE_RX_ERREUR; // Erreur de CS
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------
|
|
case ETAT_SEQUENCEUR_C_BUS_PROTOCOLE_RX_ERREUR :
|
|
{
|
|
|
|
// !!!! Voir si retour d'un NACK.... !!!!
|
|
|
|
affichage_debug(__FILE__, __LINE__, "Erreur de protocole Rx sur C-Bus", TYPE_MESSAGE_DEBUG_ERREUR);
|
|
c_bus.protocole_rx.sequenceur.etat = ETAT_SEQUENCEUR_C_BUS_PROTOCOLE_RX_REPOS;
|
|
break;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------
|
|
default :
|
|
{
|
|
sprintf(tmp, "L'état du séquenceur C-Bus.Protocole_Rx est inconnu [%i]. Il est repositionné au REPOS", c_bus.protocole_rx.sequenceur.etat);
|
|
affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_ERREUR);
|
|
c_bus.protocole_rx.sequenceur.etat = ETAT_SEQUENCEUR_C_BUS_PROTOCOLE_RX_REPOS;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (flag_cde_recue) break;
|
|
|
|
}
|
|
|
|
if (flag_cde_recue) return(1);
|
|
else return(0);
|
|
|
|
}
|
|
|
|
|
|
/*****************************************************************************************************************************************************************
|
|
Fonction : Appelée en tâche de fond, cette fonction vérifie si une réponse est à émettre vers le Compagnon (Up) ou si une commande est prête à être émise
|
|
dans le buffer de commandes Down. Si oui, elle gère via son séquenceur le formattage de la trame à émettre.
|
|
Reçoit : Rien
|
|
Renvoit : Rien
|
|
*****************************************************************************************************************************************************************/
|
|
void gestion_protocole_tx_c_bus(void)
|
|
{
|
|
uint16_t i;
|
|
uint8_t c;
|
|
uint8_t sens;
|
|
uint16_t cs;
|
|
uint8_t tx_buffer[C_BUS_MAX_TAILLE_BUFFER_TX];
|
|
uint16_t lg_tx_buffer;
|
|
char tmp[MAX_LONGUEUR_BUFFER_TEMPORAIRE_DEBUG];
|
|
|
|
|
|
switch(c_bus.protocole_tx.sequenceur.etat)
|
|
{
|
|
//--------------------------------------------------------
|
|
case ETAT_SEQUENCEUR_C_BUS_PROTOCOLE_TX_INIT :
|
|
{
|
|
// NB : le passage à l'état REPOS se fait par le séquenceur C-Bus, indépendemment de la présence de commande à émettre
|
|
break;
|
|
}
|
|
|
|
//--------------------------------------------------------
|
|
case ETAT_SEQUENCEUR_C_BUS_PROTOCOLE_TX_REPOS :
|
|
{
|
|
//..................................
|
|
// Recherche d'une trame à émettre :
|
|
if (c_bus.up.reponse.flag_ready) // Si une réponse est à émettre (en mode Up donc), elle est émise en priorité :
|
|
{
|
|
c_bus.up.reponse.flag_ready = FALSE; // RAZ du flag
|
|
sens = 'U'; // Mise à jour du sens avant préparation de la trame et envoi
|
|
}
|
|
else // Sinon, on regarde si une action est à faire en mode Down :
|
|
{
|
|
sens = 'D'; // Pour ne pas l'oublier....
|
|
|
|
if (c_bus.down.flag_attente_reponse) // Cas où une commande Down a déjà été émise et qu'on est en attente de réponse :
|
|
{
|
|
if (c_bus.protocole_tx.sequenceur.compteur_time_out == 0) // On vérifie alors si le time-out a expiré :
|
|
{
|
|
c_bus.down.flag_attente_reponse = FALSE; // RAZ du flag (qui sera éventuellement remis à 1 si la répétition a lieu)
|
|
c_bus.protocole_tx.repetitions ++; // Incrémentation du nombre de répétitions
|
|
if (c_bus.protocole_tx.repetitions > C_BUS_PROTOCOLE_TX_MAX_REPETITIONS) // Si le nombre maxi de répétitions a été dépassé, on laisse tomber la commande
|
|
{
|
|
c_bus.protocole_tx.repetitions = 0; // RAZ du compteur pour utilisation ultérieure
|
|
break; // Sortie du séquenceur
|
|
}
|
|
}
|
|
else break; // Tant qu'on est en attente d'une réponse et que le time-out n'est pas expiré, on ne traite aucun envoi en mode Down
|
|
}
|
|
else // Sinon, recherche d'une nouvelle commande à émettre en mode Down :
|
|
{
|
|
if (c_bus.down.ptr_debut_buffer_cdes != c_bus.down.ptr_fin_buffer_cdes) // Cas où il y a une commande en attente d'émission...
|
|
{
|
|
// ATTENTION : gérer les priorités ...!
|
|
|
|
if (++ c_bus.down.ptr_debut_buffer_cdes == C_BUS_MAX_TAILLE_BUFFER_CDES) c_bus.down.ptr_debut_buffer_cdes = 0;
|
|
#ifdef __DEBUG_C_BUS
|
|
c_bus.down.buffer_cdes[c_bus.down.ptr_debut_buffer_cdes].cde[c_bus.down.buffer_cdes[c_bus.down.ptr_debut_buffer_cdes].lg_cde] = 0; // On ajoute un /0 à la fin mais on ne change surtout pas la longueur qui est utilisée pour les transferts binaires.
|
|
affichage_debug_bus(TYPE_BUS_DEBUG_C_BUS, "Tx", (char *) c_bus.down.buffer_cdes[c_bus.down.ptr_debut_buffer_cdes].cde, __DEBUG_C_BUS);
|
|
#endif
|
|
}
|
|
else break; // Il n'y a pas de nouvelle commande en attente d'émission
|
|
}
|
|
}
|
|
|
|
//.....................................
|
|
// Préparation de la trame d'émission :
|
|
lg_tx_buffer = 0;
|
|
|
|
tx_buffer[lg_tx_buffer ++] = ASCII_DLE;
|
|
tx_buffer[lg_tx_buffer ++] = ASCII_SOH;
|
|
cs = ASCII_SOH; // Initialisation du CS calculé
|
|
tx_buffer[lg_tx_buffer ++] = sens;
|
|
cs += sens; // Rechargement du CS
|
|
tx_buffer[lg_tx_buffer ++] = ASCII_DLE;
|
|
tx_buffer[lg_tx_buffer ++] = ASCII_STX;
|
|
cs += ASCII_STX; // Rechargement du CS
|
|
|
|
if (sens == 'D')
|
|
{
|
|
for (i=0; (i < c_bus.down.buffer_cdes[c_bus.down.ptr_debut_buffer_cdes].lg_cde) && (lg_tx_buffer < C_BUS_MAX_TAILLE_BUFFER_TX); i++)
|
|
{
|
|
c = c_bus.down.buffer_cdes[c_bus.down.ptr_debut_buffer_cdes].cde[i];
|
|
if (c == ASCII_DLE) tx_buffer[lg_tx_buffer ++] = ASCII_DLE;
|
|
tx_buffer[lg_tx_buffer ++] = c;
|
|
cs += c; // Rechargement du CS
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (i=0; (i < c_bus.up.reponse.lg_reponse) && (lg_tx_buffer < C_BUS_MAX_TAILLE_BUFFER_TX); i++)
|
|
{
|
|
c = c_bus.up.reponse.reponse[i];
|
|
if (c == ASCII_DLE) tx_buffer[lg_tx_buffer ++] = ASCII_DLE;
|
|
tx_buffer[lg_tx_buffer ++] = c;
|
|
cs += c; // Rechargement du CS
|
|
}
|
|
}
|
|
|
|
tx_buffer[lg_tx_buffer ++] = ASCII_DLE;
|
|
tx_buffer[lg_tx_buffer ++] = ASCII_ETX;
|
|
cs += ASCII_ETX; // Rechargement du CS
|
|
|
|
c = (uint8_t)(cs & 0x00FF); // LSB du CS
|
|
if (c == ASCII_DLE) tx_buffer[lg_tx_buffer ++] = ASCII_DLE;
|
|
tx_buffer[lg_tx_buffer ++] = c;
|
|
|
|
c = (uint8_t)(cs >> 8); // MSB du CS
|
|
if (c == ASCII_DLE) tx_buffer[lg_tx_buffer ++] = ASCII_DLE;
|
|
tx_buffer[lg_tx_buffer ++] = c;
|
|
|
|
//.............................
|
|
// Envoi au driver d'émission :
|
|
write(config_serial1.filestream, tx_buffer, lg_tx_buffer);
|
|
|
|
//..........................................................
|
|
// Mise à jour des paramètres après l'émission de la trame :
|
|
if (sens == 'D') // S'il s'agissait d'une commande émise en mode Down, on lance un time-out et on indique qu'on attend la réponse :
|
|
{
|
|
c_bus.down.flag_attente_reponse = TRUE;
|
|
c_bus.protocole_tx.sequenceur.compteur_time_out = C_BUS_TIME_OUT_REPONSE_TX;
|
|
}
|
|
else ; // S'il s'agissait d'une réponse à une commande reçue en mode Up, on revient immédiatement au repos (la gestion des répétitions des commandes est de la responsabilité du maitre)
|
|
|
|
break;
|
|
}
|
|
|
|
//--------------------------------------------------------
|
|
default :
|
|
{
|
|
sprintf(tmp, "L'état du séquenceur C-Bus.Protocole_Tx est inconnu [%i]. Il est repositionné au REPOS", c_bus.protocole_tx.sequenceur.etat);
|
|
affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_ERREUR);
|
|
c_bus.protocole_tx.sequenceur.etat = ETAT_SEQUENCEUR_C_BUS_PROTOCOLE_TX_REPOS;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*****************************************************************************************************************************************************************
|
|
Fonction : Incrémente le pointeur du buffer de commandes en attente d'émission vers C-Bus
|
|
La fonction gère :
|
|
- le rebouclage en fin de buffer (buffer circulaire)
|
|
- le dépassement (quand la fin rattrape le début) en émettant un message de debug et en choissant :
|
|
. soit d'écraser la commande la plus ancienne si elle est de priorité inférieure (strictement)
|
|
. soit refuser l'ajout en laissant le pointeur de fin du buffer à sa position et en renvoyant une erreur.
|
|
Reçoit : La priorité de la commande à ajouter (permet d'arbitrer dans la cas où le buffer est plein)
|
|
Renvoit : 0 si une position disponible a été trouvée, -1 si aucune position n'est disponible.
|
|
******************************************************************************************************************************************************************/
|
|
int8_t c_bus_next_write_buffer_cdes(uint8_t priorite)
|
|
{
|
|
int8_t retour = 0;
|
|
char tmp[MAX_LONGUEUR_BUFFER_TEMPORAIRE_DEBUG];
|
|
|
|
// Incrémentation :
|
|
if (++ c_bus.down.ptr_fin_buffer_cdes == C_BUS_MAX_TAILLE_BUFFER_CDES) c_bus.down.ptr_fin_buffer_cdes = 0;
|
|
|
|
// Vérification si buffer plein :
|
|
if (c_bus.down.ptr_fin_buffer_cdes == c_bus.down.ptr_debut_buffer_cdes)
|
|
{
|
|
if (c_bus.down.buffer_cdes[c_bus.down.ptr_fin_buffer_cdes].priorite >= priorite)
|
|
{
|
|
// Décrémentation du pointeur puisqu'on ne va pas accepter la nouvelle commande qui n'a pas une priorité suffisante :
|
|
if (c_bus.down.ptr_fin_buffer_cdes == 0) c_bus.down.ptr_fin_buffer_cdes = (C_BUS_MAX_TAILLE_BUFFER_CDES - 1);
|
|
else c_bus.down.ptr_fin_buffer_cdes --;
|
|
|
|
// Message de débug :
|
|
sprintf(tmp, "Buffer de commandes C-Bus plein. La demande de stockage d'une nouvelle commande a été rejetée...");
|
|
affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_ERREUR);
|
|
|
|
// Enregistrement dans l'historique :
|
|
enregistrement_historique(TYPE_SOURCE_HISTORIQUE_SYSTEME, SYSTEME_BUS_BUFFER_COMMANDES_PLEIN, (uint32_t) 'C', 0, NULL);
|
|
|
|
retour = -1;
|
|
}
|
|
else // Dans ce cas, la nouvelle commande est plus prioritaire (strictement) à la commande existante dans le buffer et elle va la remplacer.
|
|
{
|
|
// Message de débug :
|
|
sprintf(tmp, "Buffer de commandes C-Bus plein. La demande de stockage d'une nouvelle commande a écrasée la commande la plus ancienne qui était de priorité inférieure...");
|
|
affichage_debug(__FILE__, __LINE__, tmp, TYPE_MESSAGE_DEBUG_WARNING);
|
|
}
|
|
}
|
|
|
|
return (retour);
|
|
}
|
|
|
|
|
|
|