Masa Lambası Donanım ve Yazılımı

tarih:
Merhaba.
Pcblerinden teker teker bahsetmiştim. Şimdi toplanmış hali ve yazılımının bitmemiş hali ile Masa Lambası daha doğrusu tam adı ile Uzaktan Kontrollü Aydınlatma Projesini kodlarını ve fotoğraflarını paylaşıyorum.


 50mm çapında şeffaf boruya kartları takmak için ray ekledim.







SMPS devresinin altında ölçüm yapan  analog okuma yapıldığı için oluşabilecek gürültüden etkinmemesi için aliminyum levha ile filtre yaptım.


















Sonra devreleri borunun içine yerleştirmeye başladım.





Led Aydınlatma Panelini sabitlemek için vidaladım.


Montajın ilk hali





Sonrasında anten için bir parça daha ekleyip montajı bitirdim.


Yazılım kısmına bakacak olursak:

//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);
   }
}

Yazılım kısmı henüz bitmedi. Her cihaza tekil cihaz numarası (unique ID) verilip ya yana iki cihazın ayrı ayrı kontrolünü sağlamak için geliştirmeler yapılacak.
Bunun için bilgisayar arayüzünde de iyileştirmeler yapılacak.
Yapınca onları da eklemeyi planlıyorum.