Interruption en Header ?

#1 Message par **Jérémy** » mer. 21 déc. 2016 12:17

Bonjour à tous,

Je gère une machine d'état par interruption sur reception UART. Cette machine d'état est plutôt longue alors je me pose la question suivante.

Pour aérer mon code, puis je mettre la gestion des Interruptions dans un fichier Header que j'appelle en début de programme ?

Comme c'est une INT je me dis que c'est pas forcement très conseillé niveaux réactivité !

Merci à vous

paulfjujo · #2 Message par **paulfjujo** » mer. 21 déc. 2016 21:02

bonsoir Jeremy,

Pour aerer le code du programme principal , J'utilise dans l'appli MAX7219 4 matrice8x8
simplement un
#include "Interruptions.inc"

ou est placé tout le code gerant les interrupts ..
moins de soucis qu'avec un *.H et la gestion de variables externes etc..

les variables utilisées dans le module interrupt (UART interrupt et Timer1 interrupt)
etant bien sur declarées au prealable
comme globale
AVANT l'include ...

Code : Tout sélectionner



#define MAXLEN1 128
volatile unsigned char buffer1[MAXLEN1];
volatile int Flag_Buffer1;
volatile  unsigned char c1;
volatile unsigned int i1;
volatile int Index1;
volatile unsigned int CptErr;


static int Flag_Timer1;
static unsigned int Cpt1;
static unsigned int Max_Timer1;

remarque : l'usage de variable volatile n'est pas aussi necessaire
qu'avec le C18 MPLAB ...
le compilo MikroC doit savoir les gerer implicitement.

de meme que
#include "SPI_MAX7219_4_Matrice_8x8.inc"
toute la partie qui gere l'affichage MAX7219 et matrice8x8
dans lequel je n'ai que 2 declaration extern

Code : Tout sélectionner


sfr extern  SPI_CS ;  // defini dans le main program
extern unsigned char  Aff_buffer[]; // defini dans le main program

la fonte8x8 etant un *.h
simple tableau de 1024 bytes (constantes..)

ce doit etre un reliquat de vielles habitudes issue du TURBO BASIC !
et TURBO C2.00

ce qui donne

Code : Tout sélectionner



#define VERSION "161221"

#define DIRECTORY  "C:\_MikroC\_MesProjets_MikroC\_Max7219_4_matrice8x8"
#define PROJECT "18F46K22_MAX7219_4x_Matrice8x8.mcppi"
#define SOURCE "18F46K22_test_Max71219_4xMatrice8x8_SOFT_SPI"
#define EEPROM  "18F46K22_MAX7219_4x_Mat_8x8_SPI1_Softw_EEPROM.ihex"

#define PROCESSOR "18F46K22"
#define POWER_SUPPLY 5V

#define FOSC_INTERNE
#define FOSC 8.0  //8 MHz
#define BAUD 19200  // UART1
#define Langage  Mikroc V 6.6.3
#define Timer1_LOW
#define SOFTWARE_SPI1
//#define HARDWARE_SPI1
// #define DEBUGGING

//HARDWARE module

 #define With_UART1
// UART RC6 =TX=fil blanc   RC7= RX=fil vert  Interface Prolific LTTL/USB  -> COM12 19200  -> PC XP  VBray 2014
// librairies utilisées:
// UART , C_String   C_Stdlib   Conversions , I2C
// EEPROM :

/* Config bit  :
C:\_MikroC\_MesProjets_MikroC\_Max7219_4_matrice8x8\18F46K22_FOSC_Interne_8MHz
CONFIG1H : $300001 : 0x0028
CONFIG2L : $300002 : 0x001E
CONFIG2H : $300003 : 0x003C
CONFIG3H : $300005 : 0x0098
CONFIG4L : $300006 : 0x0080
CONFIG5L : $300008 : 0x000F
CONFIG5H : $300009 : 0x00C0
CONFIG6L : $30000A : 0x000F
CONFIG6H : $30000B : 0x00E0
CONFIG7L : $30000C : 0x000F
CONFIG7H : $30000D : 0x0040


  // ac:pinout_18f46k22
  
 //   ac:Max7219_DS
 
 // ac:P18F46K22_SPI_link
   

 Miniinthebox 5281696500001
MAX7219 matricielle 8 * 8 en série interfacé huit chiffres a conduit pilote d'affichage pour Arduino
 #02816965   3.91 euros
 Disolay Leds 8x8 1088AS

 hardware
I2C2      SCL2 sur RD0   Pin 19
I2C2      SDA2 sur RD1   Pin 20

I2C1      SCL1 sur RC3   pin 18    si LCD2119
I2C1      SDA1 sur RC4   pin 23    si LCD2119

+5V                               ------- Pin 1  MAX7219 #1 Module 8x8 -  MAX7219 #2- -- MAX7219 #3---- MAX7219 #4
0V Gnd                            ------- Pin 2  MAX7219 #1 Module 8x8 -  MAX7219 #2- -- MAX7219 #3---- MAX7219 #4
SPI1      SDO      RC5   pin 24   ------- Pin 3  MAX7219 #1 Module 8x8 -  MAX7219 #2- -- MAX7219 #3---- MAX7219 #4
SPI1      SDIN     RC4   pin 23   not used
Select             RC0   pin 15   ------- Pin 4  MAX7219 #1 Module 8x8 -  MAX7219 #2- -- MAX7219 #3---- MAX7219 #4
SPI1      CLCK     RC3   pin 18   ------- Pin 5  MAX7219 #1 Module 8x8 -  MAX7219 #2- -- MAX7219 #3---- MAX7219 #4

UART1 TX  sur RC6        pin 25
UART1 RX  sur RC7        pin 26

UART2 TX  sur ED6        pin 29
UART2 RX  sur RD7        pin 30
RA0       Entree Analog  pin 2

*/

#include "built_in.h"     // for  Hi  Lo ..etc


#define CLS 12
#define CR 13
#define LF 10
#define TAB 9
#define BACK 8
#define Separator 0x20   // space

#define NbCycles_T1 8       // nb d'interrupot pour faire 1 seconde

sbit Led_Rouge at LATA5_bit;
sbit Led_Rouge_Direction  at TRISA5_bit;
//it Test_Freq at PORTC2_bit;
//


sbit  SPI_CS   at LATC0_bit;
sbit  SPI_CS_direction   at TRISC0_bit;
/* SPI bit bang
sbit  SPI_clk  at LATC3_bit;
sbit  SPI_Out at LATC5_bit;
sbit  SPI_clk_direction  at TRISC3_bit;
sbit  SPI_Out_direction  at TRISC5_bit;
*/

// Software SPI module connections
sbit SoftSpi_SDI at RC4_bit;
sbit SoftSpi_SDO at RC5_bit;
sbit SoftSpi_CLK at RC3_bit;

sbit SoftSpi_SDI_Direction at TRISC4_bit;
sbit SoftSpi_SDO_Direction at TRISC5_bit;
sbit SoftSpi_CLK_Direction at TRISC3_bit;

const code char mesg0[]=" Mikroc 6.63 "PROCESSOR" \n\r";
const code char mesg1[]=" Directory : "DIRECTORY" \n\r";
const code char mesg2[]=" Projet : "PROJECT"r\n";
const code char mesg3[]=" Source : "SOURCE"_"VERSION".c \r\n";
const code char mesg4[]=" Module Matrice 8x8 avec MAX7129\n\r";
const code char mesg5[]=" Saisir un nouveau Msg avec le terminal via <Msg=xxxx>\r\n";
const code char mesg6[]=" Mode Temperature avec <TEMP_ON> ou <TEMP_OFF>\r\n";
const code char mesg7[]= "Messages en EEPROM avec cde : <EEPROM=0> .. à 15 \r\n";
const code char mesg8[]= "°*°JOYEUX NOEL°*°";
const code char mesg9[]=" xxxxxx ";

const code char * Messages[]={mesg0,mesg1,mesg2,mesg3,mesg4,mesg5,mesg6,mesg7,mesg8,mesg9};

#define MAXLEN1 128
volatile unsigned char buffer1[MAXLEN1];
volatile int Flag_Buffer1;
volatile  unsigned char c1;
volatile unsigned int i1;
volatile int Index1;
volatile unsigned int CptErr;


static int Flag_Timer1;
static unsigned int Cpt1;
static unsigned int Max_Timer1;


int i,j,k,l,m,n;
unsigned  char TEXTE[80]; // pour teste quelconque
unsigned char TEXTE2[80]; // pour temperature Amb
unsigned char * txt;
unsigned char * txt2;
unsigned char *p;

char CRam1[32];   // for flot2asccii use
char Tampon[35];
unsigned int EAnx,EAn0,EAn1;
unsigned int SEAn0,SEAn1;
int nM;
unsigned char N1;
unsigned char  addr,donnee;
unsigned int Etat;
unsigned int clk;
unsigned long OverFlow_Timer0;
unsigned long L1,L2;
unsigned char Compteur;

float f1,f2,ff;


// MAX7129 matrice 8x8
unsigned char Aff_buffer[65];  //  8*8=64 + eventuell string terminator=0
unsigned Display_32x8_Pixel[256];
unsigned int Speed=100;

volatile struct chbits {   // 8 flags
     unsigned FrameErr:1;
     unsigned Over:1;
     unsigned Dialogue:1;
     unsigned FLT:1;
     unsigned PPS:1;
     unsigned Temper:1;
     unsigned Elapsed_Time:1;
     unsigned Mesure:1;
     unsigned First_Run:1;
   }Drapeaux ;

// ---------------------------------------

void Init_Hardware(void) ;
void Read_Msg_Eeprom( int depuis);
void Write_Msg_Eeprom( int Adr,const char * d1) ;

void Init_Timer1 (void);  //  timer 100mS * Max_timer1
void Arme_Timer1(void);   //
void Init_Timer0 (void);  //  counter in RA4 input
void strConstRamCpy(unsigned char *dest, const code char *source);
void UART1_Write_CText(const char *txt);
void RAZ_UART1(void);
unsigned char *Float2Ascii (float x, unsigned char *chaine,char precision) ;
void CRLF1(void)  ;
void Read_Msg64_Eeprom( unsigned char * T,int depuis);

#include "Interruptions.inc"


 void Read_Msg64_Eeprom(unsigned char *T, int debut)
{   int i1 ,i;
  i1=0;
  do
  {
  i = EEPROM_Read(i1+debut);
  if ( i==0) break;
  if ( i1>63) break;
  //UART1_Write(i);
  *(T+i1)=i;
  Delay_ms(1);
  i1++;
   }
  while (i!=0) ;
  *(T+i1-1)=0;
 }


// --- Copie le texte depuis FLASH ROM vers RAM
void strConstRamCpy(unsigned char *dest, const code char *source)
 {
  while (*source)*dest++ = *source++ ;
  *dest = 0 ;    // terminateur
}

void CRLF1()
{
 UART1_Write(CR);
 UART1_Write(LF);
}

void UART1_Write_CText(const char *txt)
 {
   while (*txt)
      UART1_Write(*txt++);
}

/*

void Write_Msg_Eeprom(int Adr,const char * d1)
{ int i1 ,i;
  char c1;
  i1=Adr;
  do
  {
  c1=*d1;
  EEPROM_Write(Adr,c1);
  if ( c1==0) break;
  if ( i1>1023) break;
  Delay_ms(5);
  i1++;
  }
  while (i!=0) ;
 }


void Read_Msg_Eeprom( int debut)
{   int i1 ,i;
  i1=debut;
  do
  {
  i = EEPROM_Read(i1);
  if ( i==0) break;
  if ( i1>1023) break;
  UART1_Write(i);
  Tampon[i1-debut]=i;
  Delay_ms(5);
  i1++;
   }
  while (i!=0) ;
 }
*/

void Float2Ascii (float x, unsigned char *str,char precision)
{
 /* converts a floating point number to an ascii string */
 /* x is stored into str, which should be at least 30 chars long */
 int ie, i, k, ndig;
 double y;
 ndig = ( precision<=0) ? 7 : (precision > 22 ? 23 : precision+1);
 ie = 0;
 /* if x negative, write minus and reverse */
 if ( x < 0)
 {
   *str++ = '-';
   x = -x;
 }
 /* put x in range 1 <= x < 10 */
 if (x > 0.0) while (x < 1.0)
 {
   x *= 10.0;                // a la place de =*
   ie--;
 }
 while (x >= 10.0)
 {
   x = x/10.0;
   ie++;
 }
 // in f format, number of digits is related to size
 ndig += ie;                                // a la place de =+
 //round. x is between 1 and 10 and ndig will be printed to
 // right of decimal point so rounding is ...
 for (y = i = 1; i < ndig; i++)
 y = y/10.;
 x += y/2.;
 if (x >= 10.0) {x = 1.0; ie++;}
 if (ie<0)
 {
   *str++ = '0'; *str++ = '.';
   if (ndig < 0) ie = ie-ndig;
   for (i = -1; i > ie; i--)  *str++ = '0';
 }
 for (i=0; i < ndig; i++)
 {
   k = x;
   *str++ = k + '0';
   if (i ==  ie ) *str++ = '.';
   x -= (y=k);
   x *= 10.0;
  }
 *str = '\0';
}


 void Init_Hardware()
{
  PORTA = 0b00010011;
  ANSELA=0;
  ANSELA.ANSA0=1;    //  analog input on Port A   voir page 154
  ANSELA.ANSA1=1;
  TRISA = 0b00010111 ;   // PORTA is RA0,1= analog input  RA2=sortie DAC RA3  RA4=Input  RA5,6=Digital output
  Led_Rouge_Direction=0;
  Led_Rouge=0;
  PORTA=0;
  CCP5CON=0;


  PORTB = 0xFF;
  TRISB = 0x83;    //  B0,B1 as input   ATTENTION B7 B6 for ICSP Pickit3
  ANSELB=0;

  PORTC = 0x00;          // RC0..RC5,RC7 = input RC6=Output
  ANSELC=0;
  TRISC = 0xFF;    //
  TRISC.TRISC7 = 1;  // RX - UART1
  TRISC.TRISC6 = 0;  // TX - UART1
  
  // specific SPI bit bang
  SPI_CS_direction=0;
  SPI_CS=1;
 /*
  SPI_clk_direction=0;
  SPI_Out_direction=0;
  SPI_clk=0;
  SPI_Out=0;
 */

  PORTD=0;
  ANSELD=0;
  TRISD=0xFF;
  TRISD.TRISD0 = 0;  // SCL I2C2
  TRISC.TRISD1 = 1;  // SDA I2C2
  TRISD.TRISD6 = 0;  // TX UART2
  TRISC.TRISD7 = 1;  // RX UART2

  SLRCON=0; // standard rate for PORTA,B,C,D,E
 }

void Init_ADC()
 {
       //config lecture ADC 10 bits
 ADCON0.ADON=1;      // ADC enabled chanel 0
 ADCON1.TRIGSEL=0 ; // trigger from CCP5
 ADCON2.ADFM=1;     // right justified
 ADCON2.ACQT2=1;
 ADCON2.ACQT1=1;
 ADCON2.ACQT0=0;    // 16 TAD
 ADCON2.ADCS1=1;    // select RA0 = analog input
 ADCON2.ADCS2=0;    // RA1 = Analog input
 ADCON2.ADCS0=0;    // Fosc/32
 ADCON1.PVCFG1=0;   // +Vref = +5V AVdd
 ADCON1.PVCFG0=0;
 ADCON1.NVCFG1=0;   // -Vref = Gnd AVss
 ADCON1.NVCFG0=0;
 }

void RAZ_UART1()
{
    for (i1=0;i1<MAXLEN1;i1++) buffer1[i1]=0;
    i1=0;
    Index1=0;
    c1=RC1REG;
    c1=0;
    Flag_Buffer1 =0;
    RC1IE_bit = 1;
}


void Init_Timer0(void)
{
   // init en compteur sur entree RA4
  T08BIT_bit=0; // mode 16 bits
  T0CS_bit=1;  // mode comptage sur pin T0CKI= RA4
  T0SE_bit=1; // front edge
  PSA_bit=1; //  1= Not use of prescaler => 1/1 , because, if used prescaler minimum is 1/2
  T0PS2_bit=0; // prescaler 1/2
  T0PS1_bit=0;
  T0PS0_bit=0;
  TMR0H = 0;
  TMR0L = 0;
  TMR0IP_bit=1;   // high priority
  TMR0IF_bit=0;
  TMR0IE_bit=1;
  OverFlow_Timer0=0;
  TMR0ON_bit=1;
}

void Arme_Timer1(void)
{
   // 100mS * Max_Timer1
  TMR1IF_bit         = 0;
  TMR1H         = 0x0B;
  TMR1L         = 0xDC;
  Cpt1=0;
  Flag_Timer1=0;
  TMR1ON_bit=1;     // Timer0 ON
  TMR1IE_bit= 1;
  }


void Init_Timer1(void)
 {
//FOSC=16Mhz  Prescaler 1:8; TMR1 Preload = 3035; Actual Interrupt Time : 125 ms
  T1CON         = 0x00;
  TMR1CS1_bit=0; // FOSC/4
  TMR1CS0_bit=0;
  T1RD16_bit=1;
  T1CKPS1_bit=1;  //Prescaler 1:8
  T1CKPS0_bit=1;
  TMR1H  = 0x0B;
  TMR1L  = 0xDC;
   TMR1IF_bit  = 0;
  #ifdef Timer1_LOW
  TMR1IP_bit=0;   // low level interrupt
  #else
  TMR1IP_bit=1;   // low level interrupt
  #endif
  Cpt1=0;
  Flag_Timer1=0;
  TMR1ON_bit=0;
  TMR1IE_bit =0;
}

 #include "SPI_MAX7219_4_Matrice_8x8.inc"
 /*
 void SPI_Write_To_7219(unsigned char adr, unsigned char d1, unsigned char d2);
 void Clear_Matrice(void) ;
 void Affiche_Char(unsigned char c, unsigned int v);
 void Init_Module_Max7129_8x8(void);
 void Affiche_Text_Matrice(unsigned char *p, unsigned int V);
 void Affiche_CText_Matrice(const unsigned char *p, unsigned int V);
*/

void main()
{

  #ifdef FOSC_INTERNE
  //OSCCON = 0b01110010  ; //0x72 ;     //Oscillateur à 16Mhz
  OSCCON = 0b01100010  ; //0x62 ;     //Oscillateur à 8Mhz
  //OSCTUNE.PLLEN=1
  OSCTUNE=0;
  OSCTUNE.PLLEN=0;
  OSCCON2=0;
  //while (OSCCON.HFIOFS==0); // wait stable oscillator
  #else
  // Q=20Mhz
  #endif
   Delay_ms(1000);

  Init_Hardware() ;
  SPI_CS=1;
  Max_Timer1=8;
  Led_Rouge=0;

  UART1_Init(19200);
  Delay_ms(100);
  UART1_Write(CLS);   // Erase screen terminal  :it is an option on Vbray Terminal!
  Delay_ms(500);

  txt=&TEXTE[0];
  txt2=&TEXTE2[0];
  
   CRLF1();
  // presentation sur UART1
  UART1_Write_CText ("Presentation : \r\n");
  for(i=0;i<8;i++)
  {
  
    UART1_Write_CText(Messages[i]);
   }
  Delay_ms(2000);
  CRLF1();
  clk = Clock_kHz();
  strConstRamCpy(txt,"\r\nClock initiale in  =  ...  Khz \r\n");
  WordToStr(clk,CRam1);
  memcpy(txt+ 23,CRam1,5);
  UART1_Write_Text(txt);

  //RC1IE_bit=1 ;
  //RC1IP_bit=1;
  #ifdef Timer1_LOW
  TMR1IP_bit=0;   // low level interrupt
  #else
  TMR1IP_bit=1;   // low level interrupt
  #endif

   UART1_Write_CText("init ADC EA0 \r\n" )  ;
   Init_ADC();
   
   UART1_Write_CText("init SOFT SPI  RC3=Clk ,RC5=Dout  RC0=CS -> MAx7219:\r\n" )  ;
   Soft_SPI_Init();
   Init_Module_4_Max7129_8x8();
   UART1_Write_CText("Clear Matrice 2x 8x8\r\n" )  ;
   Clear_Matrices() ;

   PEIE_bit=1;
   RCON.IPEN = 1;       // enable priority levels  , car TMR1 => low interrupt
   PEIE_bit = 1;          // Enable Peripheral interrupt
   GIE_bit  = 1;         // Enable Global interrupt
   
   UART1_Write_CText("Init et test interrupt Timer1  8 x 125 msec soit 2 sec \r\n" );
   Max_Timer1=8;
   Init_Timer1();
   Arme_Timer1();
   TXREG1='$';
   CRLF1();
   while(Flag_Timer1==0);
   TXREG1='#';
   CRLF1();
  
    UART1_Write_CText("Display <0123456789> sur matrices Leds \r\n");
    Clear_Matrices() ;
    Affiche_CText_Matrice("    ",1);
    Affiche_CText_Matrice("0123456789", 25);
    Led_Rouge=~Led_Rouge;
    Delay_ms(2000);
    Led_Rouge=~Led_Rouge;
    
     ///  Affiche temperature ambiante   sur terminal only !
     UART1_Write_CText("Display <J=   0  T°AMB= 48.3 °C> sur matrices Leds\r\n");
     Clear_Matrices() ;
     Affiche_CText_Matrice("    ", 1);
     strConstRamCpy(txt2,"J= ");
     k=strlen(txt2);
     ByteToStr(Compteur,CRam1);
     strcat(txt2+k,CRam1); // 3 digits utiles
     k=strlen(txt2);
     strConstRamCpy(txt2+k," T°AMB= ");
     k=ADC_Read(0);
     f1=(float)k*50.0/1024.0;
     Float2Ascii (f1,CRam1,1);
      k=strlen(txt2);
     strcat(txt2+k,CRam1);
     k=strlen(txt2);
     strConstRamCpy(txt2+k,"°C");
     UART1_Write_Text(txt2);  CRLF1();
      k=strlen(txt2);
     Led_Rouge=~Led_Rouge;
      for(i=0;i<k;i++)
      {
       if (*(txt2+i)=='°')*(txt2+i)=126;  // char °  de  la table Ascii_8x8[1024]
     }
     txt2=&TEXTE2[0];
     Affiche_Text_Matrice(txt2, 80);
     Delay_ms(2000);
     
     

  UART1_Write_CText("Affiche Messages 0 à 15  stockes en EEPROM du PIC18F \r\n" )   ;
  for (i=0;i<15;i++)
  {
  k=i<<6;
  Read_Msg64_Eeprom(txt,k);
  UART1_Write_CText("Eeprom # ");
  WordToHex(k,CRam1);UART1_Write_Text(CRam1);UART1_Write(TAB);
  UART1_Write_Text(txt);    CRLF1();
  Affiche_Text_Matrice(txt, 25);
   }

         // affiche °°° Joeux noel °°° par defaut
     Clear_Matrices() ;
     Affiche_CText_Matrice("    ", 1);
     txt=&TEXTE[0];
     strConstRamCpy(txt,Messages[8]);
     UART1_Write_CText("Message 8 : ");
     UART1_Write_Text(txt);  CRLF1();
     k=strlen(txt); // => 24
     for(i=0;i<k;i++)
     {
       if (*(txt+i)=='°')*(txt+i)=126;  // char °  de  la table Ascii_8x8[1024]
     }
     txt=&TEXTE[0];
     Affiche_Text_Matrice(txt, 80);
     Delay_ms(2000);

    Drapeaux.Temper=0 ;
    Compteur=0;
    Speed=80;
    RAZ_UART1();  // init Interrupt UART1
    
    while (1)
    {
     Clear_Matrices() ;
     Affiche_CText_Matrice("    ", 1);

    // affichage Temperature ambiante
     if (Drapeaux.Temper==1)
     {
     strConstRamCpy(txt2,"J= ");
     k=strlen(txt2);
     ByteToStr(Compteur,CRam1);
     strcat(txt2+k,CRam1); // 3 digits utiles
     UART1_Write_Text(txt2)  ;
     UART1_Write(TAB);

      txt2=&TEXTE2[0];
     strConstRamCpy(txt2,"T°.Amb=");
     k=ADC_Read(0);
     f1=(float)k*50.0/1024.0;
     Float2Ascii (f1,CRam1,1);
     k=strlen(txt2);
     strcat(txt2+k,CRam1);
      k=strlen(txt2);
     strConstRamCpy(txt2+k,"°C");
     UART1_Write_Text(txt2);  CRLF1();
     k=strlen(txt2);
     for(i=0;i<k;i++)  if(*(txt2+i)=='°') *(txt2+i)=126;
     Affiche_Text_Matrice(txt2, Speed);
     }
     else
     {
      txt=&TEXTE[0];
      UART1_Write_Text(txt);  CRLF1();
      for(i=0;i<strlen(txt);i++)  if(*(txt+i)=='°') *(txt+i)=126;
      Affiche_Text_Matrice(txt, Speed);
     }
     Delay_ms(1000);

     Compteur++;
     

    Init_Timer1();
    Arme_Timer1();
    while((Flag_Timer1==0) && ( Flag_Buffer1==0));
    
    // test si reception de commande venant du terminal (UART1)
    if (Flag_Buffer1==1)
    {
       p= strstr(buffer1,"Msg=");  // p pointer result
       if ((p>0) && (strlen(buffer1)>6))
       {
        k=strlen(buffer1);
        if ((k>6) && (k<84))
         {
           UART1_Write_Text("\r\nhello, i get your Msg!\r\n");
           strcpy(txt,buffer1+4);
          }
       }  //p
       p= strstr(buffer1,"TEMP_ON");  // p pointer result
       if (p>0)
       {
        Drapeaux.Temper=1;
        k=strlen(buffer1);
        UART1_Write_CText("\r\nOK, Temper is ON!\r\n");
       } //p
       p= strstr(buffer1,"TEMP_OFF");  // p pointer result
       if (p>0)
       {
        Drapeaux.Temper=0;
        UART1_Write_CText("\r\nOK, Temper is OFF!\r\nRetour au display txt \r\n");
       } //p
       p= strstr(buffer1,"Speed=");  // p pointer result
       if (p>0)
       {
         k=strlen(buffer1);
         if(k>6)
         {
           #ifdef DEBUGGING
           // test si tous les digits sont des chiffres
          CRLF1();UART1_Write_Text(buffer1+6);CRLF1();
          #endif
          m=0;
          for (i=0;i<(k-6);i++)
          {
             if ((*(buffer1+6+i)>='0')&&(*(buffer1+6+i)<='9'))  m++;
          }
          if (m==(k-6))
          {
          n= atoi(buffer1+6);
          #ifdef DEBUGGING
            UART1_Write_CText("\r\n m= ");
            WordToStr(n,CRam1);
            UART1_Write_Text(CRam1);CRLF1();
          #endif
           if ((n>1)&&(n<512)) Speed=n;
           UART1_Write_CText("\r\nChange Speed To ");
           WordToStr(Speed,CRam1);
           UART1_Write_Text(CRam1);CRLF1();
          }
         }
         #ifdef DEBUGGING
          UART1_Write_CText("\r\n m= ");
          WordToStr(m,CRam1);
          UART1_Write_Text(CRam1);CRLF1();
         #endif
       } //p
       p= strstr(buffer1,"EEPROM=");  // p pointer result
       if (p>0)
       {
         k=strlen(buffer1);
         if((k>7)&&(k<10))
         {
          m=0;
          for (i=0;i<(k-7);i++)
          {
             if ((*(buffer1+7+i)>='0')&&(*(buffer1+7+i)<='9'))  m++;
          }
          if (m==(k-7))
          {
            n= atoi(buffer1+7);
        //  #ifdef DEBUGGING
            UART1_Write_CText("\r\n m= ");
            WordToStr(n,CRam1);
            UART1_Write_Text(CRam1);UART1_Write(TAB);
        //  #endif
           if ((n>=0)&&(n<16)) 
           {
           k=n<<6;
        //  #ifdef DEBUGGING
           UART1_Write_CText("  Eeprom Msg adresse ");
           WordToHex(k,CRam1);
           UART1_Write_Text(CRam1);CRLF1();
         //  #endif
            Read_Msg64_Eeprom(txt,k);
            }
          }
         }
       } //p
       
      RAZ_UART1();
     } // flag
   }
 }

#3 Message par **Jérémy** » jeu. 22 déc. 2016 11:03

Bonjour Paul et tout le monde,

quand je regarde dans le dossier où est stocké mon programme , je ne vois pas de .inc . A quoi correspond ce format ?

Pour résumé ce que je crois avoir compris . Je place mes INT dans un fichiers .inc. Avant je prends soin de déclarer mes variables pour quelle soient reconnues !

J'ai 3 INT : TIMER0 ,TIMER1 et UART avec chacune des variables temporaire et globales.

VOICI mon fichier INT:

Code : Tout sélectionner

//########################     INTERRUPTION     ################################
void interrupt(){

  if ((TMR1IF_bit) && (TMR1IE_bit)) {   //  TIMER 1 interruption toute les 100 ms
      TMR1IF_bit = 0;       // RAZ Flag
      TMR1H      = 0x3C;    // Offset
      TMR1L      = 0xB0;

      Chrono_temp++;  // Incrementation toute les 100ms

      if (Chrono_temp >= 10){
          Chrono_temp = 0;
          Rouge = ~Rouge ;
          Chrono--;
           if (Chrono==0)
              {
                Fin_Chrono = 1;
              }
        }
  }

 if ((TMR0IF_bit) && (TMR0IE_bit)) {
    TMR0IF_bit = 0;           // RAZ Flag
    TMR0       = 6;           // Offset
    Sablier++;                // Incrementation de Sablier toute les 1 ms
    if ( Sablier >= 1000){
       Sablier_S++;           // Incrementation de Sablier_S toute les 1 seconde
       Rouge = ~Rouge ;
       Sablier = 0;
     }
  }

// Lecture des données dans le buffer UART par INT
  if (RCIF_bit == 1) {      // Si INT UART détecté

    temp = UART1_Read();      // On récupere et stock la donnée

    switch (Valeur){

           case 0:{
                    if (temp == 'O')         // "OK"
                        Valeur = 1;
                    else if (temp == 'C')    // "CMTI" ou "CMGS" ou "CSQ"
                         Valeur = 20;
                    else if (temp == '"')    // "N° de tel" ou "Gdh" ou "SM"
                         Valeur = 30;
                    else if (temp == '>')    // "Fleche"
                         Valeur = 50;
                    else if (temp == 'E')    // "ERROR"
                         Valeur = 100;
                    else
                        Valeur = 0;
                    break;
                  }
           case 1:{
                    if (temp == 'K')
                        Valeur = 2;
                    else
                        Valeur = 0;
                    break;
                  }
           case 2:{
                    if (temp == 13)
                        Valeur = 3;
                    else
                        Valeur = 0;
                    break;
                  }
           case 3:{
                    if (temp == 10)
                        Ok = 1;        // On a recu le mot "OK , on léve le drapeau
                    Valeur = 0;
                    break;
                  }
           case 20:{
                    if (temp == 'M')
                        Valeur = 21;
                    else if (temp == 'S')
                        Valeur = 25;
                    else
                        Valeur = 0;
                    break;
                  }
           case 21:{
                    if (temp == 'T')
                        Valeur = 22;
                    else if (temp == 'G')
                        Valeur = 23;
                    else
                        Valeur = 0;
                    break;
                  }
           case 22:{
                    if (temp == 'I')
                       {
                          CMTI = 1;     // On a recu "CMTI", on léve le drapeau
                          Valeur = 0;
                        }
                    else
                        Valeur = 0;
                    break;
                  }
           case 23:{
                    if (temp == 'S')
                       {
                          CMGS = 1;     // On a recu "CMGS", on léve le drapeau
                          Valeur = 0;
                        }
                    else
                        Valeur = 0;
                    break;
                  }
           case 25:{
                    if (temp == 'Q')
                          Valeur = 26;
                    else
                        Valeur = 0;
                    break;
                  }
           case 26:{
                    if (temp == ':')       // On a recu "CSQ" on enregistre la valeur
                          Valeur = 27;
                    else
                        Valeur = 0;
                    break;
                  }
           case 27:{
                    if (temp == ' ')
                          Valeur = 28;
                    else
                        Valeur = 0;
                    break;
                  }
           case 28:{
                    if (temp >= '0' && temp <= '9')
                       {
                         Val_Signal[0] = '0' ;
                         Val_Signal[1] = temp ;
                       }
                    Valeur = 29;
                    break;
                  }
           case 29:{
                    if (temp >= '0' && temp <= '9')
                       {
                         Val_Signal[0] = Val_Signal[1] ;
                         Val_Signal[1] = temp ;
                       }

                    Val_Signal[2] = 0;
                    Valeur = 0;
                    break;
                  }
           case 30:{
                    if (temp == '+')                // On enregistre le numéro de téléphone
                       {
                          Numero_tel[0] = temp;
                          i = 1;
                          Valeur = 31;
                        }
                     else if (temp == '2')          // On enregistre la date
                          Valeur = 40;
                     else
                        Valeur = 0;
                  };break;
           case 31:{
                     if (temp >= '0' && temp <= '9')
                        {
                          Numero_tel[i] = temp;
                          i++;
                        }
                     else if (temp == '"')
                        {
                          Numero_tel[i] = 0;
                          i = 0;
                          Valeur = 0;
                        }
                      else
                        {
                          Numero_tel[0] = 0;
                          i=0;
                          Valeur = 0;
                        }
                  };break;
           case 40:{
                    if (temp == '0')
                        Valeur = 41;
                    else
                        Valeur = 0;
                    break;
                  }
           case 41:{
                    if (temp == '1')
                       {
                         Gdh[0] = temp;
                         i = 1;
                         Valeur = 42;
                       }
                    else
                        Valeur = 0;

                    break;
                  }
           case 42:{
                     if (temp != '"')
                        {
                          Gdh[i] = temp;
                          i++;
                        }
                     else
                        {
                          Gdh[i] = 0;   // Je termine le Gdh par un "NULL" terminateur
                          i = 0;
                          Valeur = 43;
                        }
                     break;
                  }
           case 43:{
                    if (temp == 13)
                        Valeur = 44;
                    else
                        Valeur = 0;
                    break;
                  }
           case 44:{
                    if (temp == 10)
                       {
                         i=0;
                         SMS_Recu[0] = 0;
                         Valeur = 45;
                       }
                    else
                        Valeur = 0;
                    break;
                  }
           case 45:{
                     if (temp != 10)
                        {
                          SMS_Recu[i] = temp;
                          i++;
                        }
                     else
                        {
                          SMS_Recu[i] = 0;  // Je rajoute un terminateur "NULL"
                          i = 0;
                          Fin_SMS_recu = 1; // Je signale que j'ai fini d'enrregistrer le message
                          Valeur = 0;
                        }
                     break;
                  }
           case 50:{
                    if (temp == ' ')
                       Fleche = 1;   // Je léve le drapeau
                    Valeur = 0;
                    break;
                  }
           case 100:{
                    if (temp == 'R')
                        Valeur = 101;
                    else
                        Valeur = 0;
                    break;
                  }
           case 101:{
                    if (temp == 'R')
                        Valeur = 102;
                    else
                        Valeur = 0;
                    break;
                  }
           case 102:{
                    if (temp == 'O')
                        Valeur = 103;
                    else
                        Valeur = 0;
                    break;
                  }
           case 103:{
                    if (temp == 'R')
                        Erreur = 1;   // Je léve le drapeau
                        Valeur = 0;
                    break;
                  }

           default: valeur = 0;
    }
 }
}

Je place tout ca dans un fichier .inc et avant je mets ceci :
ce qui donne

Code : Tout sélectionner

//##################    DECLARATION VARIABLES/CONSTANTES     ###################
//##############################################################################
char Gdh[30];
char SMS_Recu[50];
char Numero_tel[20];         // tableau pour placer le numéro de téléphone en string format : {"+336********"}
char Composition_numero[30];
char Val_Signal[7];
char Val_Heures[4];
char Val_Minutes[4];
char Val_Secondes[4];
char Val_Jours_restant[4];
char Val_Heures_restant[4];
char Val_Minutes_restant[4];
char Val_Secondes_restant[4];

unsigned char Jours_restant=0,  Heures=0, Minutes=0, Secondes=0, Signal=0, temp=0, Erreur=0, Chrono_temp=0 ;
unsigned char Valeur=0, Ok=0, CMTI=0, CMGS=0, Fin_SMS_recu=0, Fleche=0;
unsigned char Demande_Lancement=0, Demande_Lancement_Reveil=0, Lancement=0, Fin_Chrono=0, Flag_Mah=0;
unsigned char Etat_module=0;

unsigned int i=0, j=0, Sablier=0, Sablier_S=0;

unsigned long Chrono=0, epoch1=0, epoch2=0, diff=0;

TimeStruct ts1, ts2 ;     // déclaration des structures pour le calcul du temps

#include "interruptions.inc"

paulfjujo · #4 Message par **paulfjujo** » jeu. 22 déc. 2016 11:24

bonjour,

Je vois que tu as bien compris le principe ...

, je ne vois pas de .inc . A quoi correspond ce format ?

ce n'est pas un format specifique .. un simple fichier texte au format ascii
inc correspond à include
qui etait tres utilisé avec d'autres langages... comme le TURBO BASIC
on aurait pu aussi mettre un fichier *.toto ou autre extension
("toto" utilisé en Fortran ! sur un solar 16/65 et un disque dur de 50Mo .. à 50KF)

remarque :
microC n'est pas tres finaud .. pour l'extension des fichiers de sauvegarde EEPROM du PIC
*iHEx .. de fortes changes d'ecrabouiller ou confondre avec le *.Hex
je rajoute toujours XXXXXEEPROM.iHEX pour bien voir la difference entre les 2 fichiers
XXXXXHEX le code,et XXXXX.iHex l'Eeprom
on peut aussi sauvegarder l'eeprom au format *eed

#5 Message par **Jérémy** » jeu. 22 déc. 2016 11:39

Ok pou le mot non spécifique !

Par contre cela le formate sans jolie couleur ca fait un fichiers texte tout moche !
Avec le .h, il y a seulement des problèmes avec les variables ? car je n'en ai pas trop et je préférais utiliser cela , si tu me dis que ca fonctionne aussi.

Merci pour tes petites précisions !

paulfjujo · #6 Message par **paulfjujo** » jeu. 22 déc. 2016 11:59

Par contre cela le formate sans jolie couleur ca fait un fichiers texte tout moche !

utilise alors
#include "Interruptions.h"
mais ce fichier *.h dans "Other Files" du project manager au lieu de "Header files"

même si ce n'est pas dans les regles de l'art.

Qui est en ligne

Bienvenue sur FantasPic