IHM.cpp

00001 #include "IHM.h"
00002 #include "all_includes.h"
00003 #include <stdarg.h>  // Pour va_list ... dans IHM_printf
00004 #include <stdio.h>   // Pour vprintf et setprintf 
00005 #define CAN_REMOTE CANType(2)
00006 //
00007 
00008 IHM::IHM(PinName CANRx, PinName CANTx): can(CANRx,CANTx)
00009 {
00010     can.frequency(1000000);                                               /*Baud rate : kbits/s */
00011     can.attach(callback(this,&IHM::can_ISR_Reader)); /* Fonction d'interruption CAN*/
00012 //    can.attach(&IHM,&can_ISR_Reader); /* Fonction d'interruption CAN*/ Modif BL Mai 2018
00013 }
00014 void IHM::LCD_printf(const char* format, ...)
00015 {
00016     unsigned char i,j;
00017     va_list arg;
00018     va_start(arg,format);
00019     curseur=curseur+vsprintf(tableau_ecran+curseur%64,format,arg);
00020     if(curseur>31)
00021     {   
00022         for(i=32; i<curseur;i++)
00023         {
00024             tableau_ecran[i%32]=tableau_ecran[i];
00025         }
00026         curseur=curseur%32;
00027     }
00028     else
00029     {
00030         for(i=0; i<32;i++)
00031         {
00032             if(tableau_ecran[i]==0)
00033                 tableau_ecran[i]=20;
00034         }   
00035     }
00036     va_end(arg);
00037     tableau_ecran[32]='\0';
00038     for(j=0; j<4; j++) {
00039         trame_Tx.id=LCD_CHAR0+j;
00040         trame_Tx.type=CANData;
00041         trame_Tx.len=8;
00042         for(i=0; i<8; i++)
00043             trame_Tx.data[i]=tableau_ecran[i+j*8];
00044         while(!can.write(trame_Tx));
00045         wait_us(150);
00046     }    
00047 }
00048 unsigned char JOG_valeur,mise_a_jour_JOG=0,mise_a_jour_COD=0;
00049 void IHM::can_ISR_Reader(void)
00050 {
00051     if (can.read(can_MsgRx[FIFO_ecriture])) {
00052         // FIFO gestion
00053         FIFO_ecriture=(FIFO_ecriture+1)%SIZE_FIFO;
00054         // myled[0] = !myled[0];
00055         // ledC= !ledC;
00056     }
00057  }
00058 void IHM::CAN_automate_reception(void)
00059 {
00060     static signed char FIFO_lecture=0,FIFO_occupation=0,FIFO_max_occupation=0;
00061     FIFO_occupation=FIFO_ecriture-FIFO_lecture;
00062     if(FIFO_occupation<0)
00063         FIFO_occupation=FIFO_occupation+SIZE_FIFO;
00064     if(FIFO_max_occupation<FIFO_occupation)
00065         FIFO_max_occupation=FIFO_occupation;
00066     if(FIFO_occupation>SIZE_FIFO)
00067         while(!can.write(CANMessage(LCD_OVERFLOW,CANStandard)));
00068     if(FIFO_occupation!=0) {
00069         switch(can_MsgRx[FIFO_lecture].id) {
00070             case JOG_DATA:
00071                 JOG_valeur=can_MsgRx[FIFO_lecture].data[0];
00072                 mise_a_jour_JOG=1;
00073                 break;
00074             case COD_DATA:
00075                 COD_valeur=can_MsgRx[FIFO_lecture].data[0];
00076                 mise_a_jour_COD=1;
00077                 break;
00078              default:
00079                 break;
00080         }
00081         FIFO_lecture=(FIFO_lecture+1)%SIZE_FIFO;
00082     }
00083 }
00084 /* FILE: IHM.c */
00085 /****************************************************************************************/
00086 /* MODULE NAME: IHM 16x2                                                                */
00087 /*                                                                                      */
00088 /* AUTHOR     : Jacques-Olivier KLEIN                                                   */
00089 /*              Bruno LARNAUDIE                                                         */
00090 /*                                                                                      */
00091 /* EMAIL      : jacques-olivier.klein@u-psud.fr                                         */
00092 /*              bruno.larnaudie@u-psud.fr                                               */
00093 /*                                                                                      */
00094 /* INSTITUTION: IUT de CACHAN - 9 av. de la div. Leclerc - 94230 CACHAN                 */
00095 /*                                                                                      */
00096 /* DATE       : 12/07/2012                                                              */
00097 /* CPU        : FREESCALE MC9S12XS128MAA                                                */
00098 /* BOARD      : CACHAN Xboard + IHM16x2                                                 */
00099 /* OS         : None                                                                    */
00100 /*                                                                                      */
00101 /* DESCRIPTION: Fonctions d'accès au Lcd émulé passant par le bus CAN                   */
00102 /****************************************************************************************/
00103 
00104 
00105 /****************************************************************************************/
00106 /* FUNCTION NAME: IHM_init                                                              */
00107 /* DESCRIPTION  : Initialise l'afficheur IHM                                            */
00108 /* RETURN       : VOID                                                                  */
00109 /****************************************************************************************/
00110 
00111 
00112 
00113 /****************************************************************************************/
00114 /* FUNCTION NAME: IHM_gotoxy                                                            */
00115 /* DESCRIPTION  : Modifie la position du curseur sur l'afficheur LCD de la carte IHM    */
00116 /* RETURN       : VOID                                                                  */
00117 /* PARAMETER  1 : UINT8 x : indice de la ligne   (0 à 1)                                */
00118 /* PARAMETER  2 : UINT8 y : indice de la colonne (0 à 15)                               */
00119 /****************************************************************************************/
00120 void IHM::LCD_gotoxy (UINT8 y, UINT8 x)
00121 {
00122     curseur=(y*16+x)%32;
00123 }
00124 
00125 
00126 
00127 /****************************************************************************************/
00128 /* FUNCTION NAME: IHM_clear                                                             */
00129 /* DESCRIPTION  : Efface le LCD                                                         */
00130 /* RETURN       : VOID                                                                  */
00131 /****************************************************************************************/
00132 void IHM::LCD_clear(void)
00133 {
00134     UINT8 i;
00135     curseur=0;
00136     for(i=0; i<32; i++)
00137         tableau_ecran[i]=32;
00138     while(!can.write(CANMessage(LCD_CLEAR,CANStandard)));
00139     wait_us(150);
00140 }
00141 /****************************************************************************************/
00142 /* FUNCTION NAME: BAR_set                                                             */
00143 /* DESCRIPTION  : commande les 10 LED du bargraph                                                       */
00144 /* PARAMETER  1 : UINT16 valeur : ordre d'allumage, exprimé sur les 10 bits de droite.
00145                   Le bit k doit valoir 0 pour allumer la LED k, 1 pour l'éteindre.
00146                   Exemple :  ~(1<<9) allume la LED 9, ~0x00F allume les 4 LED 0 à 3                                                                 */
00147 /****************************************************************************************/
00148 void IHM::BAR_set(UINT16 valeur)
00149 {
00150     trame_Tx.id=BAR_SET;
00151     trame_Tx.type=CANData;
00152     trame_Tx.len=2;
00153     trame_Tx.data[0]=valeur>>8;
00154     trame_Tx.data[1]=(UINT8)valeur;
00155     while(!can.write(trame_Tx));
00156 }
00157 
00158 
00159 /****************************************************************************************/
00160 /* FUNCTION NAME: JOG_read                                                             */
00161 /* DESCRIPTION  : indique la position (parmi les 8 possibles) et l'enfoncement du Jog. */
00162 /* RETURN       : un octet UINT8 qui indique la position (RIGHT, LEFT, UP, DOWN + 4 combinaisons)
00163                   et l'enfoncement (PUSH) du Jog, exprimés sur 5 bits utiles.*/
00164 
00165 /*         - Si le Jog est au repos : la fonction renvoie 0 (0x00).
00166          - si le Jog n'est pas au repos : 1 à 3 bits peuvent être mis à 1 dans l'octet renvoyé.
00167            Il est intéressant d'utiliser les masques définis en constantes.
00168            La signification des 8 bits de la valeur renvoyée est:
00169                      0   0   0   RIGHT   UP   PUSH   LEFT   DOWN
00170            Plusieurs bits peuvent être à 1 en même temps. Par exemple :  RIGHT + UP + PUSH
00171            à 1 indiquent que le Jog est en position "Nord Est " (UP+RIGHT) et qu'il est enfoncé.
00172            Si le Jog est simultanément enfoncé et positionné à droite, la fonction renvoie
00173            (0001 0100) en binaire, soit 0x14. Exprimée avec les masques, la valeur renvoyée vaut
00174            JOG_MSK_RIGHT | JOG_MSK_PUSH  (0x14). */
00175 /**************************************************************************************************/
00176 /**************************************************************************************************/
00177 /* utiliser les Constantes symboliques de IHM.h pour interpréter la valeur renvoyée par le jog... */
00178 /**************************************************************************************************/
00179 
00180 UINT8 IHM::JOG_read(void)
00181 {
00182     while(!can.write(CANMessage(JOG_REQ,CANStandard)));
00183 
00184     while(mise_a_jour_JOG==0)
00185         CAN_automate_reception();
00186     mise_a_jour_JOG=0;
00187     return JOG_valeur;
00188 
00189 }
00190 
00191 
00192 /***************************************************************************************************/
00193 /* FUNCTION NAME: COD_read                                                                         */
00194 /* DESCRIPTION  : indique la rotation effectuée par le codeur incrémental.                         */
00195 /* RETURN       : un octet UINT8 dont la valeur entre 0 et 255 indique la rotation du
00196                   codeur incrémental depuis l'initialisation du codeur (cad de la carte IHM),
00197                   exprimée en douzièmes de tours. Le codeur dispose en effet de 12 positions
00198                   et la valeur retournée s'incrémente/se décrémente à chaque 12e de tour.
00199                   Par exemple, si le codeur a été tourné de 2 tours et demi, la valeur
00200                   retournée vaut 12+12+6 = 30 = 0x1E (le codeur a effectué 30 douzièmes de tour)   */
00201 /***************************************************************************************************/
00202 
00203 UINT8 IHM::COD_read(void)
00204 {
00205     while(!can.write(CANMessage(COD_REQ,CANStandard)));
00206     while(mise_a_jour_COD==0)
00207         CAN_automate_reception();
00208     mise_a_jour_COD=0;
00209     return COD_valeur;
00210 
00211 }
00212