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