Version:0.9 StartHTML:0000000105 EndHTML:0000127650 StartFragment:0000001499 EndFragment:0000127634 mikroIDE
  #define Version "10-01-2016"
//usage de strtok pour decortique rla commande led RGB
// utilisation de la POV pour afficher les couleurs de 8 leds RGB sans sortie (hardware) PWM !
// 4mS maxi par couleur 24mS / led   192 mS pour les 8 leds
// Attention PWM bas sur rapport des  Duree Timer2 / Duree Timer4
// il est IMPERATIF que Timer4 soit toujours > Timer2
// dernier test    Timer1 max =  250*4*4*4/32=> 0.5mS @ 32Mhz
// Commande individuelle ou collective sur les 8 leds carte Easyled port B


 #define Source "18F45K22_8leds_RGB_TMR2_500uS_160110.c"
//  MCU:             PIC18F45k22
//  Dev.Board:       MikroE Ready For PIC avec PIC18F45K22
//  Docu:

 #define Project "18F45K22_8leds_RGB_2016.mcppi"
 //#define With_TMR1
 #define Carte_8leds_RGB
 #define Carte_EasyLeds
//  #define DEBUGGING
// #define OSCILLATEUR_INTERNE
// #define  TEST_FOSC
 #define With_UART1
 #define PROCESSOR 18F45k22
 #define POWER_SUPPLY_5V

 #ifdef OSCILLATEUR_INTERNE
 #define FOSC 16.0  // MHz
 #define BAUD 19200  // UART1
 // P18F45K22_FOSCinterne_No_PLL.cfgsch
 #else
 #define FOSC 32.0  // MHz   avec Q=16Mhz
 #define BAUD 38400  // UART1
 // P18F47J53_Q16MHz_48MHz_w_PLL.cfgsch
 #endif


#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

/* EasyLed Board sur connecteur port B
 sbit LED0  at LATB0_bit;
 sbit LED1  at LATB1_bit;
 sbit LED2  at LATB2_bit;
 sbit LED3  at LATB3_bit;
 sbit LED4  at LATB4_bit;
 sbit LED5  at LATB5_bit;
 sbit LED6  at LATB6_bit;
 sbit LED7  at LATB7_bit;
 */

 // ac:Board_8Led_RGB

 // ac:Schem_8leds_RGB
 
// carte 8 lED RGB V2 KEYES KB45041  MiniInthebox
// selection couleur
 /*
 sbit SetColorR at LATC0_bit;
 sbit SetColorV at LATC1_bit;
 sbit SetColorB at LATC2_bit;

// selection de Led RGB
 sbit RGB_Led0 at LATD0_bit;
 sbit RGB_Led1 at LATD1_bit;
 sbit RGB_Led2 at LATD2_bit;
 sbit RGB_Led3 at LATD3_bit;
 sbit RGB_Led4 at LATD4_bit;
 sbit RGB_Led5 at LATD5_bit;
 sbit RGB_Led6 at LATD6_bit;
 sbit RGB_Led7 at LATD7_bit;
 */
 
#define EasyLeds LATB
#define Leds_RGB LATD


unsigned char CRam1[80];
char TEXTE[128];
char *txt;
/*
char IntValue[12];
char txt0[] = " Ready for PIC  ";
char txt1[] = "18F45K22 proto  ";
char txt2[] = "with bootloader ";
char txt3[] = "Test 8 leds RGB ";
char txt4[] = "Mesure ";
 */
 
const char Colors[][6]={"Rouge","Vert ","Bleu ","..?.."};
volatile unsigned int Flag_Timer0;
volatile unsigned int Cpt0;
volatile unsigned int Flag_Timer1;
volatile unsigned int Cpt1;

unsigned int i,j,k,l;                              // Loop variable
unsigned int M;
unsigned int EA0,EA1,EA2 ;   // 3 mesures ANA => 3 consignes R,G,B
unsigned int Table_EA[8];
unsigned int Nbval;
int Flag_First_Run=0;

// pour test FOSC
unsigned long Freq;
float f1;

unsigned char Cde,Pos,Etat_PORTB;  // traitement Rx UART pour 8 EasyLeds
unsigned char  LedNum;  // Easyleds card
//-- RGB card ---

unsigned char c,cc,cx;
static unsigned char RGB_Led[8][3];  // tableau des 8 leds avec chacune ses 3 valeurs de couleur R,G,B
unsigned char Cde_RGB_Leds[8]={0xFE,0xFD, 0xFB,0xF7,0xEF,   0xDF, 0xBF,0x7F};
unsigned char Cde_RGB_Colors[3]={6,5,3};
volatile char RGB_Led_Now;
volatile char Cpt_RGB_Leds; // 0  7
volatile char Cpt_Color, SetColor;  // 0  2  nulmero de couleur 0=R, 1=G , 2=B
unsigned int ValColor;
unsigned char ColorR,ColorV,ColorB;



#define MAXLEN1 128
unsigned char buffer1[MAXLEN1];
unsigned int Index1=0;
unsigned int i1=0;
unsigned int UART1_DataReady=0;
unsigned char c1=0;
unsigned char *p1;


void strConstRamCpy(char *dest, const char *source);
void Init_Timer4(void);
void Init_Timer1(void);
void Init_Timer2(unsigned char x);
void UART1_Write_CText(const char *txt1);
void CRLF1(void);
void RAZ_UART1(void);
void Init_Hardware(void);
void Liste_Table(void);
void  LOAD_Table_RGB(void);


void Interrupts() iv 0x0008 ics ICS_AUTO
{
//UART1
#ifdef With_UART1
  if((RC1IF_bit==1) && (RC1IE_bit==1))
  {
     c1 = RCREG1;
       //UART_Write('*');
     if(OERR1_bit)
      {
       CREN1_bit = 0;
       CREN1_bit = 1;
      }
     if(FERR1_bit)
     {
       c1 = RCREG1;
       //c1 = 0;
     }

     if (c1==13)
      {
      UART1_DataReady=1;
      buffer1[i1]=0;
      Index1=i1;
      i1=0;
      c1=0;
     }
     else
     {
       buffer1[i1]=c1;
        Index1=i1;
        i1++;
      }
     if (i1 >=MAXLEN1)
      {
          UART1_DataReady=2;
          RC1IE_bit=0 ;    //interdit IT Reception UART
          buffer1[i1]=0;
          Index1=i1;
          i1=0;
          c1=0;
      }
   }
   #endif
   

   //   ====  IT Timer2  =============
  if((TMR2IE_bit==1) && (TMR2IF_bit==1))      // TM2 maxi 250 => 8mS
  {

    LATD=0xFF;  // Leds RGB sur port D
    TMR2ON_bit=0;
    TMR2IF_bit=0;
   }
   //   ====  IT Timer4  =============
  if((TMR4IE_bit==1) && (TMR4IF_bit==1))      // TMR4 cal  8,128mS
  {
      RGB_Led_Now =(1<< Cpt_RGB_Leds);
      //LATB=RGB_Led_Now;   // EasyLeds
      LATD = Cde_RGB_Leds[Cpt_RGB_Leds];
      cx= PORTC & 0xF8 ;
      SetColor=Cde_RGB_Colors[Cpt_Color];
      LATC= cx +   SetColor;
       cc= RGB_Led[Cpt_RGB_Leds][Cpt_Color];
      Init_Timer2(cc);    // doit toujours se terminer AVANT la nouvelle interrupt Timer4
      Cpt_Color++;
      if (Cpt_Color >2)  // every 8x3=24 mS, on change de led
      {
        Cpt_Color=0 ;
        Cpt_RGB_Leds++;
        if (Cpt_RGB_Leds>7) Cpt_RGB_Leds=0;
       }

      TMR4IF_bit=0; // Raz Flag
  }

  /* #ifdef With_TMR0
  //   ====  IT Timer0  =============
  if((TMR0IE_bit==1) && (TMR0IF_bit==1))
  {
    #ifdef DEBUGGING
    TXREG1='*';
    #endif
    Cpt0++;
    if(Cpt0>NB_IT_TMR0)
     {
       Flag_Timer0=1;
       TMR0IE_bit=0;  // interdit interrupt
       Cpt0=0;
       TMR0ON_bit=0; // stop timer
     }
      // 1000msec at 48MHz et prescaler=256
      TMR0H= 0x48; // hi 18661;
      TMR0L =0xE5 ; // Lo 18661;
      TMR0IF_bit=0; // Raz Flag
  }
  #endif
  */
  /* #ifdef With_TMR1
  //   ====  IT Timer1  =============
  if((TMR1IE_bit==1) && (TMR1IF_bit==1))
  {
      // TMR1IE_bit=0;  // interdit interrupt
      //Cpt1++;
      //if (Cpt1>2)
      if (Cpt_Color>2)
      {
         // TXREG1='$';  // pour debugging sur UART1
         // Cpt1=0;
          Cpt_Color=0;
          Cpt_RGB_Leds++;
          if (Cpt_RGB_Leds>7) Cpt_RGB_Leds=0;
      }
      Flag_Timer1=1;
      // TMR1ON_bit=0; // stop timer
      // 25mS  at 48MHz  28036 => 6D84  prescaler =8
      // TMR1H= 0x6D; // hi 28036;
      // TMR1L =0x84 ; // Lo 28036;
      // 24 mS at 16 Mhz
       TMR1H= 0xA2; // hi 41535;
       TMR1L =0x3F ; // Lo 41535;
       TMR1IF_bit=0; // Raz Flag
  }
  #endif
   */
}

void Init_Timer2(unsigned char x)
 {
  T2CON=0;
  //prescaler select=1x => 1/4
  T2CKPS1_bit=0;
  T2CKPS0_bit=1;
   //prescaler select=11 => 1/16
  //T2CKPS1_bit=1;
  //T2CKPS0_bit=1;
  // postscaleer =1/1  select=0000
  // T2OUTPS3_bit=0;
  // T2OUTPS2_bit=0;
  // T2OUTPS1_bit=0;
  // T2OUTPS0_bit=0;
  // postscaleer =1/16  select=1111     8mS    250*16*4*4/8=> 8,0 mS @ 8Mhz
  //T2OUTPS3_bit=1;
 // T2OUTPS2_bit=1;
  T2OUTPS1_bit=1;
  T2OUTPS0_bit=1;
   // postscaleer =1/8  select=0111        4mS   250*8*4*4/8=> 8,0 mS @ 8Mhz
  //T2OUTPS3_bit=0;
  // postscaleer =1/4  select=0111      250*4*4*4/32=> 0.5mS @ 32Mhz    (ou 2mS at 8Mhz)
  T2OUTPS3_bit=1;
  T2OUTPS1_bit=0;

  TMR2=0;
  PR2= x ;    // 250* postscaler * Prescaler * 4 / FOSC= 250*16*4*4/8=> 8,0 mS @ 8Mhz
  TMR2IF_bit=0;     // Reset Timer1 Flag
  TMR2IE_bit=1;     //disable interrupt TMR4
  TMR2ON_bit=1;
}

void Init_Timer4()
 {
  T4CON=0;
  // postscaleer =1/8  select=0111
  // T4OUTPS3_bit=0;
  // T4OUTPS2_bit=1;
  // T4OUTPS1_bit=1;
  // T4OUTPS0_bit=1;
  // postscaleer =1/16  select=1111   8,128 mS   254*16*4*4/8=> 8,128 mS @ 8MHz
  // T4OUTPS3_bit=1;
  // postscaleer =1/8  select=0111  4,064 mS   254*8*4*4/8=> 4,064 mS @ 8MHz
  //T4OUTPS3_bit=0;
  //T4OUTPS2_bit=1;
  // postscaleer =1/4  select=0011  2,032 mS   254*4*4*4/8=> 2,032 mS @ 8MHz
  T4OUTPS3_bit=0;
  T4OUTPS2_bit=0;
  T4OUTPS1_bit=1;
  T4OUTPS0_bit=1;
  //prescaler select=1x => 1/16
  // T4CKPS1_bit=1;
  // T4CKPS0_bit=1;
  //prescaler select=01 => 1/4
  T4CKPS1_bit=0;
  T4CKPS0_bit=1;
  TMR4=0;
  PR4= 254 ;     // 254*16*4*4/8=> 8,128 mS @ 8MHz
  TMR4IF_bit=0;     // Reset Timer1 Flag
  TMR4IE_bit=1;     // Disable interrupt TMR4
  TMR4ON_bit=1;
  //IPR5.TMR4IP=1;
}

void Init_Timer1(void)
{
// T1CON.RD16=1 ;  // Mode 16 bits
// T1RUN_bit=0 ;  //  Device clock is NOT derived from Timer1 oscillator
 T1CKPS1_bit=1;  // prescaler =1/8
 T1CKPS0_bit=1;
 T1OSCEN_bit=0; // Secondary Oscillator Disabled
 T1CON.SYNC=0;   // Synchro extern clock input with Fosc  (ignore)
 T1CON.TMR1CS1=0;  // clock source= Fosc/4
 T1CON.TMR1CS0=0;
 T1CON.TMR1ON=0;   // Stop timer1
// 25mS  at 48MHz  28036 => 6D84  prescaler =8
//  TMR1H= 0x6D; // hi 28036;
//  TMR1L =0x84 ; // Lo 28036;
// 128mS  at 16MHz  1535  05FF   prescaler =8
// TMR1H= 0x05; // hi 1535;
// TMR1L =0xFF ; // Lo 1535;
// 24mS  at 16MHz  41535  A23F  prescaler =4
 TMR1H= 0xA2; // hi 41535;
 TMR1L =0x3F ; // Lo 41535;
  //----
  IPR1.TMR1IP=1;      // set high priority for Timer1
  RCON.IPEN = 1;      // Enable Low & High interrupt priority model.
  TMR1IF_bit=0;      // raz flag interrupt
  INTCON.PEIE = 0;    // enable interupt Peripheriques
  T1CON.TMR1ON=0;     // desactive Timer1
  PIE1.TMR1IE=0;      // Disable Interrupt Timer1
  GIE_bit = 0;     // Desactive global interrupt
}


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


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

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

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


void Init_Hardware()
{
  PMD0=0;
  C1ON_bit = 0;       // Disable comparators
  C2ON_bit = 0;
  PORTB = 0;
  TRISB=0x00;       //  All Output for 8 leds
  ANSELB=0;
  LATB=0;

  PORTA = 0xFF;
  TRISA=0b11100111 ;   // RA3,RA4 as output  RA1,2,5=input  RA0 =Analog
  ANSELA=0x01;   // RA0 as analog

  ANSELC=0;
  PORTC = 0xFF;      // set PORTC all inoputs  RC6 will be output for UART1
  TRISC=0b10111000 ;

  ANSELE=0;
  TRISE=0;
  PORTE=0xFF;

  PORTD = 0;  // pour LCD
  TRISD=0;
  LATD=0xFF;
  ANSELD  = 0;       // Configure AN pins as digital I/O
  HLVDCON.HLVDEN=0;
  }
  
/*
void PrintHandler(char c) {
  UART1_Write(c);
}
*/
 void Liste_Table()
 { int i;
    for (i=0;i<8;i++)
           {
             UART1_Write_CText("Lednum=");UART1_Write(i+48);
             UART1_Write_CText(" Rouge=");ByteToStr(RGB_Led[i][0],CRam1); UART1_Write_Text(CRam1);
             UART1_Write_CText(" Vert =");ByteToStr(RGB_Led[i][1],CRam1); UART1_Write_Text(CRam1);
             UART1_Write_CText(" Bleu =");ByteToStr(RGB_Led[i][2],CRam1); UART1_Write_Text(CRam1);
             CRLF1();
           }
 }
 
 void  LOAD_Table_RGB()
 {
  int i, Flag;
  unsigned char cx;
  UART1_Write_CText("Charge EEPROM PIC -> Table \r\n");
 // if(GIE_bit==1) Flag=1;
 // TMR4ON_bit=0;
 // GIE_bit=0;
   cx=0;
  for (i=0;i<8;i++)
             {
               RGB_Led[i][0]=EEPROM_Read(cx);
               RGB_Led[i][1]=EEPROM_Read(cx+1);
               RGB_Led[i][2]=EEPROM_Read(cx+2);
               cx=cx+3;
              }
   // check
   Liste_Table() ;
  // if(Flag==1)
  // {
  //  TMR4ON_bit=0;
  // GIE_bit=0;
  // }
 }


void main()
{
#ifdef OSCILLATEUR_INTERNE
  // 16MHz
  OSCCON.IRCF2=1;
  OSCCON.IRCF1=1;
  OSCCON.IRCF0=1;
  /*
  //8Mhz
  OSCCON.IRCF2=1;
  OSCCON.IRCF1=1;
  OSCCON.IRCF0=0;
   // 4Mhz
  OSCCON.IRCF2=1;
  OSCCON.IRCF1=0;
  OSCCON.IRCF0=1;
  */
  OSCCON.SCS1=1;  // internal oscillator block
  OSCCON.SCS0=0;

  #ifndef DEBUGGING
 //while(OSCCON.HFIOFS==0);
  #endif
#endif

   Init_Hardware();
   txt=&TEXTE[0];
   

   Cpt_Color=0;
   LATC0_bit= 1;   // choix de couleur R,G,ou B
   LATC1_bit= 1;
   LATC2_bit= 1;
   LATD=0xFF;      // choix de led 0  7

  // Initalize USART1 (19200,8,N,1)
  UART1_Init(38400);
  while (UART1_Tx_Idle() == 1) UART1_Write(13);    // vide le buffer
  UART1_Write(CLS);    // efface l'ecran
  Delay_ms(500);       // necessaire pour effacer l'ecran
  CRLF1();

  UART1_Write_CText("Mikroc Pro 6.620\r\n ");
  UART1_Write_CText("version :"Version"\r\n");
  UART1_Write_CText("Source :"Source"\r\n");
  UART1_Write_CText("18F45K22 Ready for PIC\r\n ");
  //UART1_Write_CText("LCD COG2x16 mode 4 bits sur PORTD \r\n");
  UART1_Write_CText("UART1 via USB -> COM23 HTerminal\r\n ");
  UART1_Write_CText("Cdes Clavier pour Couleur 8 Leds RGB \r\n\r\n");
  #ifdef TEST_FOSC
  Freq = Clock_kHz();
  UART1_Write_CText(" Fosc =");
  LongWordToStr(Freq, txt) ;
  UART1_Write_Text(txt);
  UART1_Write_CText(" KHz\r\n");
  UART1_Write_CText(" Check delay de 5000mS entre # et @\r\n");
  UART1_Write('#');  CRLF1();
  Delay_ms(5000);
  UART1_Write('@');  CRLF1();
  #endif
  UART1_Write_CText("init UART1 38400,8,N,1\r\n ");   // at 32MHz



  // optional, edition du tableau
  LOAD_Table_RGB();

   Init_Timer4(); // 8 ms rearmable
   cc=250;
   Cpt_Color=0;
   Cpt_RGB_Leds=0;
   LATB=0;
   LATD=0xFF;

  // gestion des interruptions
  RCSTA1.SPEN = 1;
  RCSTA1.RCEN=1;
  RCSTA1.ADDEN=0;
  RAZ_UART1();    //RAZ buffer1 et arme RX1 Interrupt
  PEIE_bit = 1;   // Enable peripheral interrupts
  GIE_bit  = 1;   // Enable global Interrupts

      
   // Main loop
  do
  {

    if(UART1_DataReady==1)
    {
     GIE_bit=0;  // on teste tout cela au calme, sans etre perturb par les IT Timer4 ou Timer2
     TMR4ON_bit=0;
     UART1_Write_CText("Reception de : \r\n");
     UART1_Write_Text(buffer1); CRLF1();
     p1=0;
     p1=strstr(buffer1,"LED");     // cde possible LED 0  7  =0 ou =1
     if ( (p1>0) && (*(p1+4)=='=')) // buffer1 contient bien cette portion de texte
      {
        // on test le caractere apres le =
        if (  (*(p1+3)>='0') && (*(p1+3)<'8') && ( (*(p1+5)=='0')  || (*(p1+5)=='1') ))
         {
           Pos=*(p1+3)-'0';
           Cde=*(p1+5)-'0';
           // ancien Etat
           Etat_PORTB=LATB;
           UART1_Write(TAB);
           strConstRamCpy(CRam1,"Pos=  Cde=  PortB= ");
           *(CRam1+ 4)= Pos+48;
           *(CRam1+10)= Cde+48;
           if (Cde==0)   LATB = Etat_PORTB & ~(1<<Pos);   // (0xFF-(2^Pos)
           if (Cde==1)   LATB = Etat_PORTB | (1<<Pos) ; // (2^Pos);
           // nouvel etat
           Etat_PORTB=LATB;
           ByteToHex(Etat_PORTB ,CRam1+18);
           UART1_Write_Text(CRam1);
         }
        }
        // autres test de commandes
        p1=strstr(buffer1,"LEDs_OFF");     // cde possible LED 0  7  =0 ou =1
        if  (p1>0)
         {  LATB=0;
           Etat_PORTB=0;
        }
        p1=strstr(buffer1,"LEDs_ON");     // cde possible LED 0  7  =0 ou =1
        if  (p1>0)
        {  LATB=0xFF;
           Etat_PORTB=0xFF;
        }
        // ***  Cdes Leds RGB
       p1=strstr(buffer1,"RGB");
       if (p1>0)
       {
         p1=strtok(p1,",");  // 1er appel pour detection virgule
         UART1_Write_Text(p1);CRLF1();
         c=*(p1+3);
         UART1_Write_CText("Led # ");UART1_Write(c);
         c=c-48;  // numero de Led 0  7
         CRLF1();
         i=0;
         do
         {
          p1=strtok(0, ",");    // detection des separateurs (virgule) suivants
          if (p1!=0)
          {
              //UART1_Write_Text(p1);
              UART1_Write_CText("  Parametre #");
              UART1_Write(i+48); UART1_Write(TAB);
              j=1;
              for(k=0;k<strlen(p1);k++)
              {
                if (isdigit(*(p1+k))==0)
                {
                  j=0; break;
                }
              }
              if (j==1) // c'est bien un nombre !
               {
                 ValColor=atoi(p1);
                 if (ValColor>253) ValColor=253;
                 if (ValColor<1) ValColor=1;
                 if ((c>=0) && (c<8))
                 {
                   RGB_Led[c][i]=ValColor;
                   WordToStr(ValColor,CRam1);
                   UART1_Write_CText(" ValColor ");UART1_Write_CText(Colors[i]);
                   UART1_Write(TAB); UART1_Write_Text(CRam1);
                   CRLF1();
                   Delay_ms(100);
                   }
                   
               }
            }  // IF
           i++;
           if(i>4) break;
          }
           while (p1!=0) ;
           p1=0;
        } // RGB

         
         p1=strstr(buffer1,"HELP");
         if ((p1>0) || (*(buffer1)=='?'))
         {
           UART1_Write_CText("Cde LED portB avec  x=num led de 0  7, etat 1 ou 0 ex: LED1=1 ou  LED1=0 \r\n");
           UART1_Write_CText("Cde Globale LEDs PortB avec : LEDs_ON ou LEDs_OFF \r\n");
           UART1_Write_CText("Cde Reglage LEDs RGB : RGBx,RRR,VVV,BBB<CR> \r\n");
           UART1_Write_CText("ex: RGB1,128,35,12 soit  Reglage LED1 R=128 V=35 B=12\r\n");
           UART1_Write_CText("SAVE_TABLE : Sauvegarde Tableau 8 leds -> PIC EEPROM \r\n");
           UART1_Write_CText("LIST_TABLE : Liste contenu TABLE de reglage RGB des 8 leds\r\n");
           UART1_Write_CText("LOAD_TABLE : Charge PIC EEPROM -> TABLE 8 leds\r\n");
           UART1_Write_CText("SAVE_TABLE : Sauve  TABLE 8 leds RGB -> PIC EEPROM\r\n");
         }
        // todo
         p1=strstr(buffer1,"SAVE_TABLE");
         if (p1>0)
         {
            UART1_Write_CText("Sauvegarde Tableau -> PIC EEPROM \r\n");
            cx=0;
            for (i=0;i<8;i++)
             {
              EEPROM_Write(cx,RGB_Led[i][0]);   Delay_ms(25);
              EEPROM_Write(cx+1,RGB_Led[i][1]); Delay_ms(25);
              EEPROM_Write(cx+2,RGB_Led[i][2]); Delay_ms(25);
              cx=cx+3;
             }
             Liste_Table() ;
          }
         p1=strstr(buffer1,"LIST_TABLE");
         if (p1>0)
         {
           Liste_Table();
         }
          p1=strstr(buffer1,"LOAD_TABLE");
          if (p1>0)
           {
            UART1_Write_CText("Charge PIC EEPROM -> Table \r\n");
            LOAD_Table_RGB();
           }
        // autre test de comamnde
        // ...
        CRLF1();
        RAZ_UART1(); // on nettoie tout
        GIE_bit=1;
        TMR4ON_bit=1;
      }
   }
   while(1);
}

/*


Mikroc Pro 6.620
 version :10-01-2016
Source :18F45K22_8leds_RGB_TMR2_500uS_160109.c
18F45K22 Ready for PIC
 UART1 via USB -> COM23 HTerminal
 Cdes Clavier pour Couleur 8 Leds RGB

init UART1 38400,8,N,1
 Charge EEPROM PIC -> Table
Lednum=0 Rouge=250 Vert =  1 Bleu =  1
Lednum=1 Rouge=  1 Vert =250 Bleu =  1
Lednum=2 Rouge=  1 Vert =  1 Bleu =250
Lednum=3 Rouge=250 Vert =  1 Bleu =250
Lednum=4 Rouge=  1 Vert =250 Bleu =250
Lednum=5 Rouge=250 Vert =250 Bleu =  1
Lednum=6 Rouge= 12 Vert =100 Bleu =200
Lednum=7 Rouge=250 Vert =128 Bleu =  1
Reception de :
HELP
Cde LED portB avec  x=num led de 0  7, etat 1 ou 0 ex: LED1=1 ou  LED1=0
Cde Globale LEDs PortB avec : LEDs_ON ou LEDs_OFF
Cde Reglage LEDs RGB : RGBx,RRR,VVV,BBB<CR>
ex: RGB1,128,35,12 soit  Reglage LED1 R=128 V=35 B=12
SAVE_TABLE : Sauvegarde Tableau 8 leds -> PIC EEPROM
LIST_TABLE : Liste contenu TABLE de reglage RGB des 8 leds
LOAD_TABLE : Charge PIC EEPROM -> TABLE 8 leds
SAVE_TABLE : Sauve  TABLE 8 leds RGB -> PIC EEPROM

Reception de :
RGB0,12,130,12
RGB0
Led # 0
  Parametre #0         ValColor Rouge           12
  Parametre #1         ValColor Vert           130
  Parametre #2         ValColor Bleu            12

Reception de :
LIST_TABLE

Reception de :
LISTE_TABLE
Lednum=0 Rouge= 12 Vert =130 Bleu = 12
Lednum=1 Rouge=  1 Vert =250 Bleu =  1
Lednum=2 Rouge=  1 Vert =  1 Bleu =250
Lednum=3 Rouge=250 Vert =  1 Bleu =250
Lednum=4 Rouge=  1 Vert =250 Bleu =250
Lednum=5 Rouge=250 Vert =250 Bleu =  1
Lednum=6 Rouge= 12 Vert =100 Bleu =200
Lednum=7 Rouge=250 Vert =128 Bleu =  1

Reception de :
RGB1,0,0,0
RGB1
Led # 1
  Parametre #0         ValColor Rouge            1
  Parametre #1         ValColor Vert             1
  Parametre #2         ValColor Bleu             1

Reception de :
RGB1,128,255,1
RGB1
Led # 1
  Parametre #0         ValColor Rouge          128
  Parametre #1         ValColor Vert           253
  Parametre #2         ValColor Bleu             1

Reception de :
RGB1,0,255,0
RGB1
Led # 1
  Parametre #0         ValColor Rouge            1
  Parametre #1         ValColor Vert           253
  Parametre #2         ValColor Bleu             1

Reception de :
RGB3,40,255,0
RGB3
Led # 3
  Parametre #0         ValColor Rouge           40
  Parametre #1         ValColor Vert           253
  Parametre #2         ValColor Bleu             1

Reception de :
RGB7,255,40,255
RGB7
Led # 7
  Parametre #0         ValColor Rouge          253
  Parametre #1         ValColor Vert            40
  Parametre #2         ValColor Bleu           253

Reception de :
SAVE_TABLE
Sauvegarde Tableau -> PIC EEPROM
Lednum=0 Rouge=253 Vert =  1 Bleu =  1
Lednum=1 Rouge=  1 Vert =253 Bleu =  1
Lednum=2 Rouge=  1 Vert =  1 Bleu =250
Lednum=3 Rouge= 40 Vert =253 Bleu =  1
Lednum=4 Rouge=  1 Vert =250 Bleu =250
Lednum=5 Rouge=250 Vert =250 Bleu =  1
Lednum=6 Rouge= 12 Vert =100 Bleu =200
Lednum=7 Rouge=253 Vert = 40 Bleu =253



  ------------------------------

cc=97.  Cpt_Color=00.  Setcolor=03.  Cde_RGB_Leds=06.  EasyLeds=40. LATD=BF.
cc=1F.  Cpt_Color=00.  Setcolor=03.  Cde_RGB_Leds=02.  EasyLeds=02. LATD=FF.
cc=97.  Cpt_Color=02.  Setcolor=05.  Cde_RGB_Leds=05.  EasyLeds=20. LATD=FF.
cc=1F.  Cpt_Color=02.  Setcolor=05.  Cde_RGB_Leds=01.  EasyLeds=02. LATD=FF.
cc=97.  Cpt_Color=01.  Setcolor=06.  Cde_RGB_Leds=05.  EasyLeds=20. LATD=FF.
cc=01.  Cpt_Color=00.  Setcolor=03.  Cde_RGB_Leds=01.  EasyLeds=02. LATD=FD.
cc=79.  Cpt_Color=00.  Setcolor=03.  Cde_RGB_Leds=05.  EasyLeds=10. LATD=EF.
cc=01.  Cpt_Color=02.  Setcolor=05.  Cde_RGB_Leds=00.  EasyLeds=01. LATD=FF.
cc=79.  Cpt_Color=02.  Setcolor=05.  Cde_RGB_Leds=04.  EasyLeds=10. LATD=EF.
cc=01.  Cpt_Color=01.  Setcolor=06.  Cde_RGB_Leds=00.  EasyLeds=01. LATD=FF.
*/