Tek hat üzerinden birden fazla sensörün kontrolü

[ramazanacar]

Öncelikle herkese merhaba,
Pic programlama işinde biraz acemiyim. Yapmaya çalıştığım projeyi dilim döndüğünce anlatmaya çalışayım. Elimde henüz herhangi bir devre şeması yada program yok ve CCS C kullanıyorum. 
20 adet sıcaklık sensöründen gelen veriyi, tek hat üzerinden pic ile haberleştirmek istiyorum. Eğer sensörlerden herhangi biri veya birkaçı, programda belirlenen sıcaklık aralığını aştığında, sensörleri gösteren ledlerin olduğu kontrol panelindeki ledi ya da ledleri yakmasını istiyorum. Acaba bu konu ile ilgili nereden başlamalıyım? Hangi konuları araştırmalıyım? Pic e hangi sensörün veri gönderdiğini nasıl bildirebilirim. Yardımlarınız için şimdiden teşekkür ederim.

[MC_Skywalker]

DS18B20 sensörleri tek hat üzetinden sensörün ID numarasıyla ayrı ayrı okuya bilirsin. 

ilk yapman gereken ID okuyup sensörleri ona göre değerlendirirsin.

[ete]

Bana göre bu işi yapmanın 3 yolu var.
Yol-1: One Vire haberleşme yapabilen DS18B20 sensörlerine fabrikası tarafından bir ID numarası (ROM KODU)verilir.
Kısa bir program yazarak önce her birinin numarasını öğreneceksin. Daha sonra hepsini aynı hatta tek bir Data kablosu üzerinden bağlayacaksın. En sonunda da Rom kodu vererek sıcaklık ölçeceksin. Detaylarını sensör data sheetinden öğrenebilirsin.

Yol-2: I2C ile haberleşebilen bir sensör bulacaksın. Bu sensörlerin bir ID numarası olur. Bunları adres verecek şekilde bağlayabilirsin. Ama 20 adedi kurtarırmı onu bilemiyorum. Sensöre bağlı olan bir mesele. Daha sonrada adres vererek her bir sensörü okuyabilirsin. Genelde 3 bitlik adres olur . Sana 5 bitlik adres gerekiyor. Bu şekilde bir sensör varmıdır bilemiyorum. Olduğunuda pek sanmıyorum ama yinede araştırmak gerekir.

Yol-3: Her bir sensörü ayrı bir işlemciye bağlayarak her birini bir RS485 hattına bağlayacaksın. Yazılımla her birine bir ID numarası vereceksin. BU 20 adet sensör gurubunu okuyup yönlendirecek bir MASTER kartın olacak. Sensörler ise SLAVE çalışacaklar. Master hangi ID numarasına Sıcaklığını bildir emrini vermiş ise o haberleşme hattına mesajını bırakacak. Mesajı hepsi alacak ama sadece ID numarası tutan cevap verecek. Buda bir nevi adresli sıcaklık okuma sistemi gibi çalışır.
Şu anda senin için en kolay yöntem bu olsa gerek. Bu işin içinde Kesmeye bağlı RS232 haberleşmesi , sıcaklık okuma prosedirü ve Master-Slave ilişkisi bulunmaktadır. Benzer bir projeyi Basic dilinde Algoritma başlığı altında yayınlamıştım. En azından mantık olarak inceleyebilirsin. Tabiiki RS485 haberleşme sisteminide en azından donanım olarak incelemen gerekiyor.

Ete

[ramazanacar]

Öncelikle cevaplar için çok teşekkür ederim.
Ete Hocamın 3. yöntemi benim için daha uygulanabilir geldi. Benim şuan kafama oturmayan kısmı 2 veya daha fazla sensör aynı anda alarma geçerse ya da alarmdan çıkarsa, ledleri aynı anda yakıp, söndürebilir miyim tek hat üzerinden? Ya da master kart, slave kartlara tek tek sıcaklığını bildir dediğinde, bir sonraki döngüye kadar ledler durumunu koruyacak ve biraz gecikmeli de olsa durumuna göre yanıp, sönecekler mi?
Birde master kart da ki işlemci ile, slavelerdeki işlemcilerin aynı olma zorunluluğu var mı? Master daki işlemci ile slavelerdeki işlemcileri farklı kullanmayı düşünüyorum.
Ete hocamın dediği konuları araştırıp, projeye başlıyacağım. Gelişmeleri buradan yazmayı planlıyorum.

[ete]

Süre meselesi tamamen yazacağın programa senin aklına bağlı. Bir sorun olacağını sanmıyorum.
Master ve slave işlemcileri bir birlerinden farklı olabilirler. Tek ortak noktaları hepsinde de donanımsal USART olması gerekir. Olmadan da yapılabilir ama bu işi kesme'e bağlaman işin sıhhati açısından gerekli bence.

Ete

[ramazanacar]

Hocam elinize kolunuza sağlık, istediğim bilgileri aldığımı düşünüyorum. Gelişmelerden haberdar edeceğim. Saygılar. İyi çalışmalar.

[ramazanacar]

Herkese hayırlı geceler,
Bahsettiğim proje ile ilgili 30 adet ADC kanalı olması sebebiyle PIC18F45K22 yi satın aldım. Daha önceden CCS C programı ile 16F877A ile ADC uygulaması kolaylıkla yapmıştım fakat bunda ADC ayarlarını yapamıyorum. Datasheeti inceliyorum ama ingilizcem pek yeterli gelmiyor. Proteus da simule ederken "Port B is not configured a analog input" hatası alıyorum. ADC portlarının hepsini kullanmayacağım. Kendi belirlediğim ADC pinlerini analog işlemler için kullanıp, diğer pinleri giriş, çıkış birimi olarak kullanmak istiyorum. Bu işlemci ile ilgili CCS C de ADC kodlama örneği yapabilme imkanımız var mıdır acaba? Ya da nerede yanlış yapıyorum?

#include <18F45K22.h>                                // Derleyici kütüphanesinden denetleyicimizin özelliklerini getiriyoruz.
#device ADC = 10                                    // Pic 10 bit hassasiyetinde okuması için, 10 bit tanımladık. tanımlanmazsa 8 bit okur.

/*******************************DENETLEYİCİ KONFİGÜRASYON AYARLARI************************************/
#fuses XT, NOWDT, NOBROWNOUT, NOPROTECT, NOPUT, NOLVP, NOWRT, NODEBUG, NOCPD      // Seçtiğimiz denetleyicinin bazı kullandığımız veya kullanmadığımız pin özelliklerini ayarlıyoruz.

#use delay(clock=4M)                               // Osilatör hızı 4Mhz olarak ayarlıyoruz.

#use fast_io(a)                                    // Port yönlendirme komutları A portu için geçerli.
#use fast_io(b)                                    // Port yönlendirme komutları B portu için geçerli.
#use fast_io(c)                                    // Port yönlendirme komutları C portu için geçerli.
#use fast_io(d)                                    // Port yönlendirme komutları D portu için geçerli.
#use fast_io(e)                                    // Port yönlendirme komutları E portu için geçerli.

#define BUZZER pin_d0                               //d0 pinini BUZZER diye adlandırdık.

unsigned long int S_1P, S_2P, S_3P, S_4P, S_5P, S_6P, S_7P, S_8P, S_9P, S_10P, S_11P, S_12P, S_13P, S_14P, S_15P;  // İşaretsiz 16 bitlik tamsayı tipinde değişkenler tanımlandı




/******************************ALARM DEĞERLERİ****************************************/
  
unsigned long int AL_S1= 205;
unsigned long int AL_S2= 205; 
unsigned long int AL_S3= 205;
unsigned long int AL_S4= 205;
unsigned long int AL_S5= 205;
unsigned long int AL_S6= 205;
unsigned long int AL_S7= 205;
unsigned long int AL_S8= 205;
unsigned long int AL_S9= 205;
unsigned long int AL_S10= 205;
unsigned long int AL_S11= 205;
unsigned long int AL_S12= 205;
unsigned long int AL_S13= 205;
unsigned long int AL_S14= 205;
unsigned long int AL_S15= 205;


/******************************************A/D KESMESI************************************************/
#INT_AD        //A/D çevrim biti kesmesi
void ADC_Kesmesi()
{

if
(                      // Eğer
(S_1P)>=AL_S1   ||     // S_1P değeri, AL_S1 değerine eşit ya da büyük ise VEYA
(S_2P)>=AL_S2   ||     
(S_3P)>=AL_S3   ||     
(S_4P)>=AL_S4   ||    
(S_5P)>=AL_S5   || 
(S_6P)>=AL_S6   ||  
(S_7P)>=AL_S7   ||   
(S_8P)>=AL_S8   ||   
(S_9P)>=AL_S9   ||  
(S_10P)>=AL_S10 ||    
(S_11P)>=AL_S11 ||  
(S_12P)>=AL_S12 ||   
(S_13P)>=AL_S13 ||   
(S_14P)>=AL_S14 || 
(S_15P)>=AL_S15       
)

output_high (BUZZER);     // BUZZER değerini 1 yap
         else                        // Değilse,
         output_low(BUZZER);         // BUZZER değerini 0 yap
         
}



/*************************************ANA PROGRAM FONKSIYONU******************************************/
void main ()               // Ana program başlangıcı.
{

//setup_psp(PSP_DISABLED);          // PSP birimi devredışı
setup_timer_1 (T1_DISABLED);      // T1 zamanlayıcısı devre dışı
setup_timer_2 (T2_DISABLED,0,1);  // T2 zamanlayıcısı devre dışı
setup_CCP1 (CCP_OFF);             // CCP1 birimi devre dışı
setup_CCP2 (CCP_OFF);             // CCP2 birimi devre dışı


set_tris_a(0b00000000);          // a portunun hepsini çıkış olarak tanımladık.
set_tris_b(0b00111111);          // b portunu tanımladık.
set_tris_c(0b11110000);          // c portunu tanımladık.
set_tris_d(0b11111110);          // d portunu tanımladık.
set_tris_e(0b00000000);          // e portunun hepsini çıkış olarak tanımladık.


output_a(0x00);            // a portu çıkışlarını sıfırla
output_b(0x00);            // b portu çıkışlarını sıfırla
output_c(0x00);            // c portu çıkışlarını sıfırla
output_d(0x00);            // d portu çıkışlarını sıfırla
output_e(0x00);            // e portu çıkışlarını sıfırla


//setup_adc(adc_clock_internal);      // ADC, mikrodenetleyici içindeki RC osilatör frekansını kullanacak.
setup_adc(adc_clock_div_32);          // ADC clock frekansı (okuma hızı) 0,125MHz olarak (4MHz/32) belirlendi.


setup_adc_ports(sAN8);
setup_adc_ports(sAN9);
setup_adc_ports(sAN10);
setup_adc_ports(sAN12);
setup_adc_ports(sAN16);
setup_adc_ports(sAN17);
setup_adc_ports(sAN18);
setup_adc_ports(sAN19);
setup_adc_ports(sAN21);
setup_adc_ports(sAN22);
setup_adc_ports(sAN23);
setup_adc_ports(sAN24);
setup_adc_ports(sAN25);
setup_adc_ports(sAN26);
setup_adc_ports(sAN27);


enable_interrupts(INT_AD);       // AD çevrimi bitti kesmesi tanıtıldı.
enable_interrupts(GLOBAL);       // Aktif edilen tüm kesmelere izin ver.


while(1)          // Sonsuz döngü
{

/*************************************ADC OKUMA BÖLÜMÜ START******************************************/

/*******S_1 BÖLÜMÜ*******/

set_adc_channel(21);    // RD1/AN21 ucundaki sinyal A/D işlemine tabi tutulacak.
delay_us(20);           // 20 mikrosaniye hesaplama beklemesi yap.
S_1P=read_adc();       // ADC sonucu okunuyor ve S_1P değişkenine aktarılıyor.

if (S_1P>=AL_S1)         // Eğer okunan ADC değeri AL_S1 değerinden büyük ve eşit ise,
      {
         output_high(pin_a0);        // a0 pinini 1 yap.
      }
            else                     // Değilse,
            {
               output_low(pin_a0);   // a0 pinini 0 yap.
            }

delay_ms(50);           // 50 milisaniye bekle. 



/*******S_2 BÖLÜMÜ*******/

set_adc_channel(22);    // RD2/AN22 ucundaki sinyal A/D işlemine tabi tutulacak.
delay_us(20);           // 20 mikrosaniye hesaplama beklemesi yap.
S_2P=read_adc();       // ADC sonucu okunuyor ve S_2P değişkenine aktarılıyor.

if (S_2P>=AL_S2)        // Eğer okunan ADC değeri AL_S2 değerinden büyük ve eşit ise,  
      {
         output_high(pin_a1);        // a1 pinini 1 yap.
      }
            else                     // Değilse,
            {
               output_low(pin_a1);   // a1 pinini 0 yap.
            }

delay_ms(50);           // 50 milisaniye bekle. 



/*******S_3 BÖLÜMÜ*******/

set_adc_channel(23);     // RD3/AN23 ucundaki sinyal A/D işlemine tabi tutulacak.
delay_us(20);           // 20 mikrosaniye hesaplama beklemesi yap.
S_3P=read_adc();       // ADC sonucu okunuyor ve S_3P değişkenine aktarılıyor.

if (S_3P>=AL_S3)          // Eğer okunan ADC değeri AL_S3 değerinden büyük ve eşit ise,
      {
         output_high(pin_a2);        // a2 pinini 1 yap.
      }
            else                     // Değilse,
            {
               output_low(pin_a2);   // b2 pinini 0 yap.
            }

delay_ms(50);           // 50 milisaniye bekle. 



/*******S_4 BÖLÜMÜ*******/

set_adc_channel(16);     // RC4/AN16 ucundaki sinyal A/D işlemine tabi tutulacak.
delay_us(20);           // 20 mikrosaniye hesaplama beklemesi yap.
S_4P=read_adc();       // ADC sonucu okunuyor ve S_4P değişkenine aktarılıyor.

if (S_4P>=AL_S4)          // Eğer okunan ADC değeri AL_S4 değerinden büyük ve eşit ise,
      {
         output_high(pin_a3);        // a3 pinini 1 yap.
      }
            else                     // Değilse,
            {
               output_low(pin_a3);   // a3 pinini 0 yap.
            }

delay_ms(50);           // 50 milisaniye bekle. 



/*******S_5 BÖLÜMÜ*******/

set_adc_channel(17);     // RC5/AN17 ucundaki sinyal A/D işlemine tabi tutulacak.
delay_us(20);           // 20 mikrosaniye hesaplama beklemesi yap.
S_5P=read_adc();       // ADC sonucu okunuyor ve S_5P değişkenine aktarılıyor.

if (S_5P>=AL_S5)         // Eğer okunan ADC değeri AL_S5 değerinden büyük ve eşit ise,
      {
         output_high(pin_a4);        // a4 pinini 1 yap.
      }
            else                     // Değilse,
            {
               output_low(pin_a4);   // a4 pinini 0 yap.
            }

delay_ms(50);           // 50 milisaniye bekle.



/*******S_6 BÖLÜMÜ*******/

set_adc_channel(18);     // RC6/AN18 ucundaki sinyal A/D işlemine tabi tutulacak.
delay_us(20);           // 20 mikrosaniye hesaplama beklemesi yap.
S_6P=read_adc();       // ADC sonucu okunuyor ve S_6P değişkenine aktarılıyor.

if (S_6P>=AL_S6)         // Eğer okunan ADC değeri AL_S6 değerinden büyük ve eşit ise,
      {
         output_high(pin_a5);        // a5 pinini 1 yap.
      }
            else                     // Değilse,
            {
               output_low(pin_a5);   // a5 pinini 0 yap.
            }

delay_ms(50);           // 50 milisaniye bekle.



/*******S_7 BÖLÜMÜ*******/

set_adc_channel(19);     // RC7/AN19 ucundaki sinyal A/D işlemine tabi tutulacak.
delay_us(20);           // 20 mikrosaniye hesaplama beklemesi yap.
S_7P=read_adc();       // ADC sonucu okunuyor ve S_7P değişkenine aktarılıyor.

if (S_7P>=AL_S7)         // Eğer okunan ADC değeri AL_S7 değerinden büyük ve eşit ise,
      {
         output_high(pin_e0);        // e0 pinini 1 yap.
      }
            else                     // Değilse,
            {
               output_low(pin_e0);   // e0 pinini 0 yap.
            }

delay_ms(50);           // 50 milisaniye bekle.



/*******S_8 BÖLÜMÜ*******/

set_adc_channel(24);     // RD4/AN24 ucundaki sinyal A/D işlemine tabi tutulacak.
delay_us(20);           // 20 mikrosaniye hesaplama beklemesi yap.
S_8P=read_adc();       // ADC sonucu okunuyor ve S_8P değişkenine aktarılıyor.

if (S_8P>=AL_S8)         // Eğer okunan ADC değeri AL_S8 değerinden büyük ve eşit ise,
      {
         output_high(pin_e1);        // e1 pinini 1 yap.
      }
            else                     // Değilse,
            {
               output_low(pin_e1);   // e1 pinini 0 yap.
            }

delay_ms(50);           // 50 milisaniye bekle.



/*******S_9 BÖLÜMÜ*******/

set_adc_channel(25);     // RD5/AN25 ucundaki sinyal A/D işlemine tabi tutulacak.
delay_us(20);           // 20 mikrosaniye hesaplama beklemesi yap.
S_9P=read_adc();       // ADC sonucu okunuyor ve S_9P değişkenine aktarılıyor.

if (S_9P>=AL_S9)         // Eğer okunan ADC değeri AL_S9 değerinden büyük ve eşit ise,
      {
         output_high(pin_e2);        // e2 pinini 1 yap.
      }
            else                     // Değilse,
            {
               output_low(pin_e2);   // e2 pinini 0 yap.
            }

delay_ms(50);           // 50 milisaniye bekle.



/*******S_10 BÖLÜMÜ*******/

set_adc_channel(26);     // RD6/AN26 ucundaki sinyal A/D işlemine tabi tutulacak.
delay_us(20);           // 20 mikrosaniye hesaplama beklemesi yap.
S_10P=read_adc();       // ADC sonucu okunuyor ve S_8P değişkenine aktarılıyor.

if (S_10P>=AL_S10)         // Eğer okunan ADC değeri AL_S10 değerinden büyük ve eşit ise,
      {
         output_high(pin_c0);        // c0 pinini 1 yap.
      }
            else                     // Değilse,
            {
               output_low(pin_c0);   // c0 pinini 0 yap.
            }

delay_ms(50);           // 50 milisaniye bekle.



/*******S_11 BÖLÜMÜ*******/

set_adc_channel(27);     // RD7/AN27 ucundaki sinyal A/D işlemine tabi tutulacak.
delay_us(20);           // 20 mikrosaniye hesaplama beklemesi yap.
S_11P=read_adc();       // ADC sonucu okunuyor ve S_11P değişkenine aktarılıyor.

if (S_11P>=AL_S11)         // Eğer okunan ADC değeri AL_S11 değerinden büyük ve eşit ise,
      {
         output_high(pin_c1);        // c1 pinini 1 yap.
      }
            else                     // Değilse,
            {
               output_low(pin_c1);   // c1 pinini 0 yap.
            }

delay_ms(50);           // 50 milisaniye bekle.



/*******S_12 BÖLÜMÜ*******/

set_adc_channel(12);     // RB0/AN12 ucundaki sinyal A/D işlemine tabi tutulacak.
delay_us(20);           // 20 mikrosaniye hesaplama beklemesi yap.
S_12P=read_adc();       // ADC sonucu okunuyor ve S_12P değişkenine aktarılıyor.

if (S_12P>=AL_S12)         // Eğer okunan ADC değeri AL_S12 değerinden büyük ve eşit ise,
      {
         output_high(pin_c2);        // c2 pinini 1 yap.
      }
            else                     // Değilse,
            {
               output_low(pin_c2);   // e1 pinini 0 yap.
            }

delay_ms(50);           // 50 milisaniye bekle.



/*******S_13 BÖLÜMÜ*******/

set_adc_channel(10);     // RB1/AN10 ucundaki sinyal A/D işlemine tabi tutulacak.
delay_us(20);           // 20 mikrosaniye hesaplama beklemesi yap.
S_13P=read_adc();       // ADC sonucu okunuyor ve AL_S13P değişkenine aktarılıyor.

if (S_13P>=AL_S13)         // Eğer okunan ADC değeri AL_S13 değerinden büyük ve eşit ise,
      {
         output_high(pin_c3);        // c3 pinini 1 yap.
      }
            else                     // Değilse,
            {
               output_low(pin_c3);   // c3 pinini 0 yap.
            }

delay_ms(50);           // 50 milisaniye bekle.



/*******S_14 BÖLÜMÜ*******/

set_adc_channel(8);     // RB2/AN8 ucundaki sinyal A/D işlemine tabi tutulacak.
delay_us(20);           // 20 mikrosaniye hesaplama beklemesi yap.
S_14P=read_adc();       // ADC sonucu okunuyor ve S_14P değişkenine aktarılıyor.

if (S_14P>=AL_S14)         // Eğer okunan ADC değeri AL_S14 değerinden büyük ve eşit ise,
      {
         output_high(pin_b6);        // b6 pinini 1 yap.
      }
            else                     // Değilse,
            {
               output_low(pin_b6);   // b6 pinini 0 yap.
            }

delay_ms(50);           // 50 milisaniye bekle.



/*******S_15 BÖLÜMÜ*******/

set_adc_channel(9);     // RB3/AN9 ucundaki sinyal A/D işlemine tabi tutulacak.
delay_us(20);           // 20 mikrosaniye hesaplama beklemesi yap.
S_15P=read_adc();       // ADC sonucu okunuyor ve S_15P değişkenine aktarılıyor.

if (S_15P>=AL_S15)         // Eğer okunan ADC değeri AL_S15 değerinden büyük ve eşit ise,
      {
         output_high(pin_b7);        // b7 pinini 1 yap.
      }
            else                     // Değilse,
            {
               output_low(pin_b7);   // b7 pinini 0 yap.
            }

delay_ms(50);           // 50 milisaniye bekle. 
               
               
               
}
                                 
}                          // Ana programın sonu.

[ramazanacar]

Saat 01:30 oldu. Hayırlı sabahlar demek gerek herhalde.
Sorunu şu şekilde hallettim. Şu an simulasyon  normal çalışıyor. Kodları herbir sensör için yazdıktan sonra tek tek simulasyonda test ettim. Yaptığım değişiklik ise

setup_adc_ports(sAN8);
setup_adc_ports(sAN9);
setup_adc_ports(sAN10);
setup_adc_ports(sAN12);
setup_adc_ports(sAN16);
setup_adc_ports(sAN17);
setup_adc_ports(sAN18);
setup_adc_ports(sAN19);
setup_adc_ports(sAN21);
setup_adc_ports(sAN22);
setup_adc_ports(sAN23);
setup_adc_ports(sAN24);
setup_adc_ports(sAN25);
setup_adc_ports(sAN26);
setup_adc_ports(sAN27);

bu code notasyon şeklini,

setup_adc_ports(sAN21|sAN22|sAN23|sAN16|sAN17|sAN18|sAN19|sAN24|sAN25|sAN26|sAN27|sAN12|sAN10|sAN8|sAN9);

bu şekle çevirdim.
Biraz deneme yanılma ile oldu sanırım.

[ete]

Bu işlemcide PORTB nin analog olabilmesi için TERISB=255 ve ANSELB=255 olması yeterli oluyor.
Direk işlemci registerler,ne değer verilemiyormu bu C dilinde acaba?

Ete

[ramazanacar]

Hocam, verdiğiniz kodu derleyiciye benim kullandığım B portu pinlerine göre değiştirdim.

setup_adc_ports(sAN21|sAN22|sAN23|sAN16|sAN17|sAN18|sAN19|sAN24|sAN25|sAN26|sAN27|sAN12|sAN10|sAN8|sAN9);

Koda göre sondaki 4 tane B portu ADC pinini sildim ve aşağıdaki şekilde değiştirdim.

setup_adc_ports(sAN21|sAN22|sAN23|sAN16|sAN17|sAN18|sAN19|sAN24|sAN25|sAN26|sAN27);

TRISB=63
ANSELB=15

Derleyici ve simulasyonda herhangi bir problem çıkmadı normal çalışıyor. Dediğiniz gibi registerlara direkt değer verilebiliyor gibi ama CCS C ye daha vakıf olan arkadaşlarım cevap verirse, daha doğru olur.

Bide ekşide birisi böyle birşey yazmış. Ama ne demek istediğini anlamadım.
"registerlara direk erişim imkanı vermemesiyle üzen, kütüphanelerinde birçok işlem için hazır gelen fonksiyonlarıyla sevindiren pic c derleyicisi. en büyük rakibi hi tech c'dir.

edit: valthoron uyardı. istediğimiz adrese ayrıca variable tanımlamadan pointer ile ulaşabiliyormuşuz."

[furkan41]

Öncelikle herkese merhaba,
Pic programlama işinde biraz acemiyim. Yapmaya çalıştığım projeyi dilim döndüğünce anlatmaya çalışayım. Elimde henüz herhangi bir devre şeması yada program yok ve CCS C kullanıyorum. 
20 adet sıcaklık sensöründen gelen veriyi, tek hat üzerinden pic ile haberleştirmek istiyorum. Eğer sensörlerden herhangi biri veya birkaçı, programda belirlenen sıcaklık aralığını aştığında, sensörleri gösteren ledlerin olduğu kontrol panelindeki ledi ya da ledleri yakmasını istiyorum. Acaba bu konu ile ilgili nereden başlamalıyım? Hangi konuları araştırmalıyım? Pic e hangi sensörün veri gönderdiğini nasıl bildirebilirim. Yardımlarınız için şimdiden teşekkür ederim.

eğer sadece led yakacak ise ve sensörler sadece sıcaklık ölcecek ise ve bence op-amp lar ile bir karşılaştırıcı devresi kurabilirsin biraz maliyetli olur ama birşeyler tasarlanıp düşünülebilir. veya secici entegreler ilede 20 sensörü 100 ms aralıklarla ölcersin teker teker. bir hat üstünden.