Published January 27, 2019
Table Lamp with RF Control

A table lamp that can be controlled by radio frequncy. Measure light level and dimmable by 64 steps.
IntermediateWork in progressOver 2 days597
Things used in this project

Hardware components

Texas Instruments TPS5410
Microchip Pic18F26K22
HMTRP
Samsung 3528 Led chips
Texas Instruments lm2576
PCBWay Custom PCB
Microchip MCP4014
TOP244
Story

I like to control something remotely. I want to assemble a dimmable table LED light with RF control. I decided to make cover from transparent pipe.
1 / 5
All design process is shaped around pipe. Holder, smps circuit, control circuit, LED board.
1 / 9
A 12V 0.8 Amp smps is used to power LED and control circuit. To prevent EMI, an aluminum shield is placed between circuit and smps.
1 / 4
CCS C code
/Kütüphaneler
#include

#include 

#include 
#include 
#include 
#include 
#include 


//Kesmeler

#INT_RTCC
void  RTCC_isr(void)
{

}

#INT_TIMER0
void  TIMER0_isr(void)
{

}

#INT_TIMER1
void  TIMER1_isr(void)
{

}

#INT_TIMER2
void  TIMER2_isr(void)
{

}

#INT_TIMER3
void  TIMER3_isr(void)
{

}

#INT_EXT
void  EXT_isr(void)
{
   intExtState=1;
}

#INT_EXT1
void  EXT1_isr(void)
{
   intExt1State=1;
}

#INT_EXT2
void  EXT2_isr(void)
{
  intExt2State=1;

}

//Seri Port veri alma

#INT_RDA
void  RDA_isr(void)
{
   hiX(intRda);
  
   if (firstRdaInt==0)
   {
      firstRdaInt=1;
      genCounter=0;
      while(kbhit(commRf))
      {
         tempbuffer[genCounter]=getch(commRf);
         genCounter++;
      }
      tempbuffer[genCounter]='\0';
      fprintf(commdbg,"HMTRP Text: %s\r\n",tempBuffer);
    
   }
   else
   {
      fgets(rdaData,commRf);
   }
   loX(intRda);
  
   intRdaState=1;
}

#INT_RDA2
void  RDA2_isr(void)
{
   hiX(intRda2);
   fgets(rda2Data,commDbg);
   loX(intRda2);
  
   intRda2State=1;
}

//Ana Program Bloğu
void main()
{
   setup_adc_ports(sAN15);
   setup_adc(ADC_CLOCK_DIV_64|ADC_TAD_MUL_0);
/*
   enable_interrupts(INT_RTCC);
   enable_interrupts(INT_TIMER0);
   enable_interrupts(INT_TIMER1);
   enable_interrupts(INT_TIMER2);
   enable_interrupts(INT_TIMER3);
 */
  
   hmtrp(disable);
   bekle(tKisa);
   hmtrp(enable);
   bekle(tUzun);
   //Example blinking LED program
  
   fprintf(commDbg,"FiDeNet\r\n");
   set_adc_channel(15);
   delay_ms(2);
  

  
   enable_interrupts(INT_RDA);
   enable_interrupts(INT_RDA2);


//Başlangıç için debug bildirimleri

   fprintf(commRf,"FiDeNet HMTRP TEST\r\n");
   fprintf(commDbg,"Debug Port TEST\r\n");
  

   //eepromWrTest();
   //eepromRdTest();
  
   //Led Driver Conf
   digiPotInit();
   digiPotReset();
  
   adcCounter=0;
   adcSum=0;
   adcAvrg=0;
   processPlanner=0;
  
   ext_int_edge(0,H_to_L);
   ext_int_edge(1,H_to_L);
   ext_int_edge(2,H_to_L);
  
   enable_interrupts(INT_EXT);
   enable_interrupts(INT_EXT1);
   enable_interrupts(INT_EXT2);

   enable_interrupts(GLOBAL);
  
   dimmValue=20;
   onOffState=1;
   setDigiPotValue(dimmValue);
  
   bekle(tOrta);
   // Ayarlar faslı bittikten sonra interruptlar aktif olsun.


  
   hiX(iAmAlive);
   //Device ID var mı? kontrol et.
   readDevIDOk=readDevID();
  
   if (readDevIDOk==1)
   {
      fprintf(commDbg,"DevID:%s\r\n"devID);
   }
   else
   {
         fprintf(commDbg,"DevID:N/A\r\n");
    
   }
  
   //devID=
  
   while(true)
   {
    
     //eğer ilk interrupt geldiğinde firstExtInt ilk defa çalışıyorsa intExtState değişkenlerini sıfırla.
     //While döngüsü ilk turundan sonra interrupt gelirse onları al
    
     if (firstExtInt==0)
     {
         intExtState=0;
         intExt1State=0;
         intExt2State=0;
     }  
    
    
     if (intExtState==1)
     {
         intExtState=0;
         hiX(general);
         fprintf(commDbg," onOffState\r\n");
         onOffstate=!onOffState;
         if (onOffstate)
         {
            setDigiPotValue(dimmValue);
         }
         else
         {
            setDigiPotValue(0);  
         }
         fprintf(commDbg," onOffState:%u dimm:%u\r\n"onOffState,dimmValue);
         bekle(2*tOrta);
         loX(general);
         }
        
        if (intExt1State==1)
        {
            intExt1State=0;
            hiX(general);
            fprintf(commDbg,"Dimm -- \r\n");
            if (dimmValue>3)
            {
               dimmValue-=3;
            }
            else
            {
               dimmValue=0;
            }
            setDigiPotValue(dimmValue);
            fprintf(commDbg,"Dimm:%u\r\n",dimmValue);
            bekle(2*tOrta);
            loX(general);
                    
          
        }
      
        if (intExt2State==1)
        {
            intExt2State=0;
            hiX(general);
            fprintf(commDbg,"Dimm ++ \r\n");
            if (dimmValue<60 p="">            {
               dimmValue+=3;
            }
            else
            {
               dimmValue=63;
            }
            setDigiPotValue(dimmValue);
            fprintf(commDbg,"Dimm:%u\r\n",dimmValue);
            bekle(2*tOrta);
            loX(general);
            
            
       }
    
    
     if (intExt2State==1)
     {
          hiX(general);
   fprintf(commDbg,"Dimm ++ \r\n");
   if (dimmValue<60 p="">   {
      dimmValue+=3;
   }
   else
   {
      dimmValue=63;
   }
   setDigiPotValue(dimmValue);
   fprintf(commDbg,"Dimm:%u\r\n",dimmValue);
   bekle(2*tOrta);
   loX(general);
    
     }
    
    
    
    
     if( intRdaState==1)
     {
       intRdaState=0;
       fprintf(commDbg,"rdaData: %s\r\n"rdaData);
      
       strcpy(tempBuffer, myCommands[cAT].str);
       //gelen Komut ATL ise
       if (strcmp(rdaData,tempBuffer)==0)
       {
         fprintf(commRf,"OK\r\n");
       }
      
       strcpy(tempBuffer, myCommands[cATLLev].str);
       //gelen Komut ATLLev ise
       if (strcmp(rdaData,tempBuffer)==0)
       {
         fprintf(commRf,"ATLLev=%3.0f\r\n" adcAvrg);
       }
      
       strcpy(tempBuffer, myCommands[cATDmV].str);
       //gelen Komut ATDmV ise
       if (strcmp(rdaData,tempBuffer)==0)
       {
         fprintf(commRf,"ATDmV=%u\r\n" dimmValue);
       }
      
        strcpy(tempBuffer, myCommands[cATDm].str);
       //gelen Komut ATDm ise
       if (strncmp(rdaData,tempBuffer,5)==0)
       {
        
         strDataLen=strLen(rdaData);
         equalSeq=0;
         returnSeq=0;
         for (genCounter=0;genCounter         {
            if(rdaData[genCounter]=='=')
            {
               equalSeq=genCounter;
            }
          
            if(rdaData[genCounter]=='\r')
            {
               returnSeq=genCounter;
            }
          
        
         }
         fprintf(CommDbg," EqualSeq=%u; ReturnSeq=%u\r\n,"equalSeq, returnSeq);
        
         if((returnSeq>0)&&(equalSeq>0))
         {
            if (returnSeq-equalSeq==2)
            {
               tempBuffer[0]=rdaData[equalSeq+1];
               tempBuffer[1]='\0';
              
            }
            else
            {
               tempBuffer[0]=rdaData[equalSeq+1];
               tempBuffer[1]=rdaData[equalSeq+2];
               tempBuffer[2]='\0';
            }
            dimmValue=atoi(tempBuffer);
            setDigiPotValue(dimmValue);
            fprintf(commRf,"ATDm=%u\r\n"dimmValue );
          }
       }
      
      
       strcpy(tempBuffer, myCommands[cATID].str);      
       //gelen Komut ATID ise
       if (strcmp(rdaData,tempBuffer)==0)
       {
        
          if (readDevIDOk==1)
         {
            fprintf(commRf,"ATID=%s\r\n"devID);
         }
         else
         {
            fprintf(commRf,"ATID=N/A\r\n");
         }
        
       }
      
      
     }
     if( intRda2State==1)
     {
       intRda2State=0;
       fprintf(commDbg,"rda2Data: %s\r\n"rda2Data);
      
       strcpy(tempBuffer, myCommands[cATMfc].str);
       //gelen Komut ATMfc ise
       if (strcmp(rda2Data,tempBuffer)==0)
       {
         fprintf(commDbg,"ATMfc: %s\r\n" deviceData[mfc].str);
       }
      
       strcpy(tempBuffer, myCommands[cATHwID].str);
       //gelen Komut ATHwID ise
       if (strcmp(rda2Data,tempBuffer)==0)
       {
         fprintf(commDbg,"ATHwID: %s\r\n" deviceData[cHWID].str);
       }
      
       strcpy(tempBuffer, myCommands[cATSw].str);
       //gelen Komut ATSw ise
       if (strcmp(rda2Data,tempBuffer)==0)
       {
         fprintf(commDbg,"ATSw: %s\r\n" deviceData[cSWVersion].str);
       }
      
       strcpy(tempBuffer, myCommands[cATHwR].str);
       //gelen Komut ATHwR ise
       if (strcmp(rda2Data,tempBuffer)==0)
       {
         fprintf(commDbg,"ATHwR: %s\r\n" deviceData[cHwR].str);
       }
      
       strcpy(tempBuffer, myCommands[cATLLev].str);
       //gelen Komut ATLLev ise
       if (strcmp(rda2Data,tempBuffer)==0)
       {
         fprintf(commDbg,"ATLLev: %3.0f\r\n"adcAvrg);
       }
      
       strcpy(tempBuffer, myCommands[cReBoot].str);      
       //gelen Komut ReBoot ise
       if (strcmp(rda2Data,tempBuffer)==0)
       {
         fprintf(commDbg,"ReBoot: %s\r\n" deviceData[cReBoot].str);
         bekle(tUzun),
         reset_cpu();
       }
      
      
       strcpy(tempBuffer, myCommands[cATID].str);      
       //gelen Komut ATID ise
       if (strcmp(rda2Data,tempBuffer)==0)
       {
         fprintf(commDbg,"ATID=%s\r\n" devID);
      
       }
      
      
        strcpy(tempBuffer, myCommands[cATIDW].str);
       //gelen Komut ATIDW= ise
       if (strncmp(rda2Data,tempBuffer,5)==0)
       {
        
         strDataLen=strLen(rda2Data);
         equalSeq=0;
         returnSeq=0;
         for (genCounter=0;genCounter         {
            if(rda2Data[genCounter]=='=')
            {
               equalSeq=genCounter;
            }
          
            if(rda2Data[genCounter]=='\r')
            {
               returnSeq=genCounter;
            }
          
        
         }
         fprintf(CommDbg," EqualSeq=%u; ReturnSeq=%u\r\n,"equalSeq, returnSeq);
        
         strcpy(tempBuffer,"");
         for (genCounter=0;genCounter<(returnSeq-equalSeq-1);genCounter++)
         {
            tempBuffer[genCounter]=rda2Data[genCounter+equalSeq+1];
          
        
         }
         tempBuffer[genCounter]='\0';
        
         fprintf(CommDbg," tempBuffer %s\r\n,"tempBuffer);
        
        
        
         if((returnSeq>0)&&(equalSeq>0))
         {
            strcpy(devID,tempBuffer);
            writeDevId();
            setDigiPotValue(1);
            bekle(tUzun);
            setDigiPotValue(0);
            bekle(tUzun);
            setDigiPotValue(1);
            bekle(tUzun);
              
          
            reset_cpu();
          
         }
      
       }
      
        strcpy(tempBuffer, myCommands[cATIDC].str);
       //gelen Komut ATIDC= ise
       if (strcmp(rda2Data,tempBuffer)==0)
       {
            clearDevID();
            fprintf(commDbg,"Device ID Silindi.");
             bekle(tUzun);
              
          
            reset_cpu();
      
       }
      
     }
    
     processPlanner++;
    
     if( (processPlanner % 1000)==0) //500 döngüde bir ADC ölçümü al
     {
        if (adcCounter>9)
        {
            adcCounter=0;
        }
      
        
         //delay_ms(tOrta);
        
         adcArr[adcCounter]=read_adc();
        
        
         //fprintf(CommDbg,"ADC Counter: %u ADC Val : %lu\r\n"adcCounter, adcArr[adcCounter]);
         adcCounter++;
        
         adcSum=0;
        
         for (genCounter=0;genCounter<10 gencounter="" p="">         {
            adcSum += adcArr[genCounter];
            // fprintf(CommDbg,"genCounter: %lu ADC Val : %lu\r\n"genCounter, adcArr[genCounter]);
          
         }
         adcAvrg=adcSum /10;
         fprintf(CommDbg,"ADC Avrg: %f\r\n"adcAvrg);
        
      
        
     }
    
     firstExtInt=1;
    
      /*
      output_high(Pin_C2);
      delay_ms(DELAY);
       adcVal=read_adc();
      fprintf(CommDbg,"ADC Val on: %lu\r\n"adcVal);
     */
    
   }

}



//Kütüphaneler


//def.h


typedef  int1 u1;
typedef  unsigned int8 u8;
typedef  volatile unsigned int8 vu8;
typedef  unsigned int16 u16;
typedef  volatile unsigned int16 vu16;
typedef  unsigned int32 u32;


#define bekle(x) delay_ms(x)


#define rfEnable Pin_C1
#define rfConf Pin_C0


#define hiX(x) output_high(x)
#define loX(x) output_low(x)

#define disable 0
#define enable 1

#define mcpCs Pin_C5
#define mcpUd Pin_B3
#define tpsEn Pin_C4
#define debug

#define digiPotMaxValue 64


#define iAmAlive Pin_A0
#define intRda Pin_A1
#define intRda2 Pin_A2
#define general Pin_A3

//#define lcdBacklight Pin_B14

#define tSn 1000
#define tUzun 500
#define tOrta 100
#define tKisa 50
#define tMini 10
#define tMicro 1


//regs.h

/*Cihaz ile ilgili kullanılacak sabitler*/
enum sabitler{
      cHWID,
      cSWVersion,
      cHwR,
      mfc,  //manifacturer
   };
   
   typedef struct hw_strings{
      u8 sbt;
      char str[20];

   }myHwStrings;
   
   
  myHwStrings const deviceData[10]={
      cHWID,{"FD.RCL7W.MCU.R01"},
      cSWVersion,{"1.0.0"},
      cHwR,{"1.0.1"},
      mfc,{"FiDeNet UKoSis"},
   };
   
   enum enumCommands{
      cAT,
      cATHwID,
      cATSw,
      cATHwR,
      cATMfc,  //manifacturer
      cATID,
      cATIDW,
      cATIDC,
      cATLLev,
      cATDmV,
      cATDm,
      cReBoot,
      
   };
   
   typedef struct strctCommandText{
      u8 sbt;
      char str[20];

   }myHwCommands;
   
   
  myHwCommands const MyCommands[15]={
      cAT,{"AT\r"},
      cATHwID,{"ATHwID\r"},
      cATSw,{"ATSw\r"},
      cATHwR,{"ATHwR\r"},
      cATMfc,{"ATMfc\r"},
      cATID,{"ATID\r"},
      cATIDW,{"ATIDW="},
      cATIDC,{"ATIDC\r"},
      cATLLev,{"ATLLev\r"},
      cATDmV,{"ATDmV\r"},
      cATDm,{"ATDm="}
      cReBoot,{"ReBoot\r"}
   };
   
   
   
   
   
char tempBuffer[30];   // id yazma için kullanılan ara değişken
u16 counterGen;        //genel sayaç
u8 readDevIDOk=0;
u8 devIDAddr=10;
char devID[30];

u16 adcVal;
u16 adcArr[10];
u8 adcCounter;
float adcAvrg;
u16 adcSum;

u16 processPlanner;

u1 intRdaState=0;
u1 intRda2State=0;

u1 intExtState=0;
u1 intExt1State=0;
u1 intExt2State=0;

u1 firstExtInt=0;
u1 firstRdaInt=0;


char rdaData[100];
char rda2Data[100];



char strGen1[10];
u16 genCounter;
u8 genCounter2;
float temperature;
u16 backlightVal;
u8 digiPotValue;
u1 onOffState=0;
u8 dimmValue=0;
u8 strDataLen;
u8 equalSeq;
u8 returnSeq;
u8 recDimmValue;


//digipot.c

void digiPotInit(void)
{
   
   
   output_drive(mcpUd );   //CS ve UD pinlerini çıkış yap 
   output_drive(mcpCs);
   
   bekle(tMicro);
   digiPotValue=31;               // Açılış değeri
   //i2c_yaz(digi_pot_addr,digi_pot_value);

}
void digiPotInc(u8 value)
{
   
    u8 sayac;
    //Pinleri yüksek yap
    hiX(mcpCs);
    hiX(mcpUd );
    bekle(tMicro);
    
    //CS pini ile işe başla
    loX(mcpCs);
    bekle(tMicro);
    for (sayac=0;sayac!=value;sayac++)
    {
       loX(mcpUd );
       bekle(tMicro);
       hiX(mcpUd );
       bekle(tMicro);
    }
    //CS pini yüksek yap işi bitir 
    hiX(mcpCs);


}


void digiPotDec(u8 value)
{  
    u8 sayac;
    //Pinleri yüksek yap
    hiX(mcpCs);
    loX(mcpUd );
    bekle(tMicro);
    
    //CS pini ile işe başla
    loX(mcpCs);
    bekle(tMicro);
    for (sayac=0;sayac!=value;sayac++)
    {
       hiX(mcpUd );
       bekle(tMicro);
       loX(mcpUd );
       bekle(tMicro);
       
    }
    //CS pini yüksek yap işi bitir 
    hiX(mcpCs);


}


void setDigiPotValue(u8 value)
{
    u8 sayac;
    //digi_pot_value=i2c_oku(digi_pot_addr);
    //pwm_value değeri sensor okuması kısmında hata algılanırsa karşıma çıkacak
    //eğer bu değer 0 dan farklı ise led voltajlarını o zaman kontrol edeceğim. Böylece
    //sistem kapalı iken led voltajı hatası (kısadevre ) vermeyecek
    
    //pwm_value=value;
   
   if(value
   {
      
      
      if(value>digiPotValue)
      {
         #IFDEF debug
             fprintf(CommDbg,"buyuk digi_pot_value: %u value:%u\r\n"digiPotValue,value);
   
         #ENDIF
         
         sayac=value-digiPotValue;
         digiPotInc(sayac);
         digiPotValue=value;
         //i2c_yaz(digi_pot_addr,digi_pot_value);
         
      }
      
      if(value
      {
         #IFDEF debug
             fprintf(commDbg,"kucuk digi_pot_value: %u value:%u\r\n"digiPotValue,value);
   
         #ENDIF
         sayac=digiPotValue-value;
         digiPotDec(sayac);
         digiPotValue=value;
         //i2c_yaz(digi_pot_addr,digi_pot_value);
         
      }
   }
   else
   {
      #IFDEF debug
         fprintf(commDbg,"digi_pot_max_value out of range\r\n");
      #ENDIF
   }
   #IFDEF debug
      fprintf(commDbg,"digi_pot_value: %u\r\n"digiPotValue);

   #ENDIF
   if(digiPotValue==0)
   {
      loX(tpsEn);

      #IFDEF debug
         fprintf(commDbg,"Pin_drv_enable:0 \r\n");
      #ENDIF
   
   }
   else
   {
      hiX(tpsEn); //Sabit akım led sürücü devresini Pin_drv_enable 1 yapılıp açılır
   }
  
  
   

}
void digiPotReset(void)
{
   digiPotDec(70); // digi_pot_hangi değerde olursa olsun değeri 0'a çek
   digiPotValue=0;
   loX(tpsEn);
   //i2c_yaz(digi_pot_addr, digi_pot_value);
}


//func.c

void hmtrp(u8 state)
{
   if (state==disable)
   {
      hiX(rfEnable);
      hiX(rfConf);
   }
   if(state==enable)
   {
      loX(rfEnable);
      hiX(rfConf);
   }
}
Credits

Fikret

24 projects • 37 followers
fidenetgaraj.blogspot.com
Table Lamp with RF Control

Things used in this project

Hardware components

Story

Code

CCS C code

Credits

Fikret

Comments

Embed the widget on your own site

Table Lamp with RF Control

Table Lamp with RF Control

Things used in this project

Hardware components

Story

Code

CCS C code

Credits

Fikret

Comments

Related channels and tags
