ტემპერატურისა და სინათლის დონის მონიტორი LCD ეკრანზე ეკრანზე NOKIA 5110: 4 ნაბიჯი

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:18

Გამარჯობა ყველას!

ამ განყოფილებაში ჩვენ ვქმნით მარტივ ელექტრონულ მოწყობილობას ტემპერატურისა და სინათლის დონის მონიტორინგისთვის. ამ პარამეტრების გაზომვები ნაჩვენებია LCD NOKIA 5110 -ზე. მოწყობილობა ემყარება მიკროკონტროლერს AVR ATMEGA328P. მონიტორინგის მოწყობილობა აღჭურვილია DS18B20 ციფრული თერმომეტრით და ფოტორეზისტორით, რომ გაზომოს სინათლის დონე.

ნაბიჯი 1: კომპონენტების აღწერა

მონიტორინგის მოწყობილობის ძირითადი კომპონენტები:

• მიკროკონტროლერი AVR «ATMEGA328P»
• მონოქრომული გრაფიკული LCD «NOKIA 5110»
• პროგრამირებადი რეზოლუცია 1 მავთულის ციფრული თერმომეტრი «DS18B20»
• სინათლეზე დამოკიდებული რეზისტორი
• მავთულები

მიკროკონტროლერი AVR «ATMEGA328P»

მონიტორინგის მოწყობილობა იყენებს მიკროკონტროლის შემდეგ პერიფერიულ მახასიათებლებს:

1. 16 ბიტიანი ტაიმერი/მრიცხველის შეწყვეტა
2. 8 არხიანი 10 ბიტიანი ADC
3. სამაგისტრო/მონა SPI სერიული ინტერფეისი

მონოქრომული გრაფიკული LCD «NOKIA 5110»

სპეციფიკაციები:

1. 48 x 84 წერტილიანი LCD ეკრანი
2. სერიული ავტობუსის ინტერფეისი მაქსიმალური მაღალი სიჩქარით 4 Mbits/S
3. შიდა კონტროლერი/დრაივერი «PCD8544»
4. LED უკანა შუქი
5. იმუშავეთ ძაბვაზე 2.7-5 ვოლტზე
6. დაბალი ენერგომოხმარება; შესაფერისია ბატარეის გამოყენებისთვის
7. ტემპერატურის დიაპაზონი -25˚C– დან +70˚C– მდე
8. სიგნალის CMOS შეყვანის მხარდაჭერა

LCD მისამართის დამუშავება (მისამართები):

მეხსიერების მისამართის განლაგება, რომელიც ნაჩვენებია LCD ეკრანზე (DDRAM) არის მატრიცა, რომელიც შედგება 6 სტრიქონისგან (Y მისამართი) Y- მისამართიდან 0-მდე Y- მისამართი 5-მდე და 84 სვეტიდან (X მისამართი) X-მისამართიდან 0-დან X- მდე მისამართი 83. თუ მომხმარებელს სურს LCD ეკრანზე შედეგის ჩვენების პოზიციაზე წვდომა, უნდა მიმართოს X- მისამართსა და Y- მისამართს შორის ურთიერთობას.

მონაცემები, რომლებიც გაიგზავნება ჩვენებაზე არის 8 ბიტიანი (1 ბაიტი) და ის განლაგდება როგორც ვერტიკალური ხაზი; ამ შემთხვევაში, Bit MSB იქნება ქვედა და Bit LSB იქნება ზედა, როგორც ნაჩვენებია სურათზე.

პროგრამირებადი რეზოლუცია 1 მავთულის ციფრული თერმომეტრი DALLAS «DS18B20»

Მახასიათებლები:

1. უნიკალური 1-Wire® ინტერფეისი კომუნიკაციისთვის მოითხოვს მხოლოდ ერთ პორტს
2. შეამცირეთ კომპონენტების რაოდენობა ინტეგრირებული ტემპერატურის სენსორთან და EEPROM- თან
3. ზომავს ტემპერატურას -55 ° C– დან +125 ° C– მდე (–67 ° F– დან +257 ° F– მდე)
4. ± 0.5 ° C სიზუსტე -10 ° C– დან +85 ° C– მდე
5. პროგრამირებადი რეზოლუცია 9 ბიტიდან 12 ბიტამდე
6. გარე კომპონენტები არ არის საჭირო
7. პარაზიტული ენერგიის რეჟიმი ოპერაციისთვის მოითხოვს მხოლოდ 2 ქინძისთავს (DQ და GND)
8. ამარტივებს განაწილებული ტემპერატურის მგრძნობიარე პროგრამებს მულტიდროპის შესაძლებლობით
9. თითოეულ მოწყობილობას აქვს უნიკალური 64-ბიტიანი სერიული კოდი, რომელიც ინახება ბორტზე
10. მოქნილი მომხმარებლის მიერ განსაზღვრული არასტაბილური (NV) სიგნალიზაციის პარამეტრები მაღვიძარის ძებნის ბრძანებით ამოიცნობს მოწყობილობებს ტემპერატურით პროგრამირებული ლიმიტების მიღმა

პროგრამები:

1. თერმოსტატული კონტროლი
2. სამრეწველო სისტემები
3. სამომხმარებლო პროდუქტები
4. თერმომეტრები
5. თერმულად მგრძნობიარე სისტემები

სინათლეზე დამოკიდებული რეზისტორი

სინათლის დამოკიდებული რეზისტორი (LDR) არის გადამყვანი, რომელიც ცვლის მის წინააღმდეგობას, როდესაც სინათლე ეცემა მის ზედაპირზე.

როგორც წესი, LDR- ს ექნება ერთი მეგაოჰამიდან ორ მეგაოჰმამდე სრული სიბნელეში, ათიდან ოც კილოოჰმამდე ათ ლუქსზე, ორიდან ხუთ კილოჰმამდე 100 ლუქსზე. სენსორის ორ კონტაქტს შორის წინააღმდეგობა მცირდება სინათლის ინტენსივობით ან იზრდება გამტარობა სენსორის ორ კონტაქტს შორის.

გამოიყენეთ ძაბვის გამყოფი წრე ძაბვის ცვლილებისადმი წინააღმდეგობის ცვლილების გადასაყვანად.

ნაბიჯი 2: მიკროკონტროლერის ფირმის კოდი

#ifndef F_CPU #განსაზღვრეთ F_CPU 16000000UL // კონტროლერი ეუბნება ბროლის სიხშირეს (16 MHz AVR ATMega328P) #endif

// SPI INTERFACE DEFINES #define MOSI 3 // MOSI it PORT B, PIN 3 #define MISO 4 // MISO it PORT B, PIN 4 #define SCK 5 // SCK it PORT B, PIN 5 #define SS 2 // SS ეს არის PORT B, PIN 2

// გადატვირთეთ დისპლეი #განსაზღვრეთ RST 0 // გადააყენეთ ის პორტი B, PIN 0

// DISPLAY MODE SELECT - შეყვანა ბრძანების/მისამართის ან მონაცემთა შეყვანის შესარჩევად. #განსაზღვრეთ DC 1 // DC ეს არის პორტი B, PIN 1

// კოდების მასივი უარყოფითი სენსტატიკური const unsigned char neg [4] = {0x30, 0x30, 0x30, 0x30};

// ციფრების კოდების მასივი [0..9] სტატიკური const ხელმოუწერელი char font6x8 [10] [16] = {{0xFC, 0xFE, 0xFE, 0x06, 0x06, 0xFE, 0xFE, 0xFC, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01}, // 0 {0x00, 0x00, 0x18, 0x1C, 0xFE, 0xFE, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x01, 0x01, 0x001, 0x0C, 0x8E, 0xCE, 0xE6, 0xE6, 0xBE, 0x9E, 0x0C, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01}, // 2 {0x00, 0x04, 0x06, 0x26, 0x76, 0xFE, 0xDE 0x8C, 0x00, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01}, // 3 {0x3C, 0x3E, 0x7C, 0x60, 0x60, 0xFC, 0xFE, 0xFC, 0x00, 0x00, 0x00, 0x00 0x01, 0x03, 0x01}, // 4 {0x1C, 0x3E, 0x3E, 0x36, 0x36, 0xF6, 0xF6, 0xE4, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01}, // 5 {0xFC, 0xFE, 0xFE, 0x36, 0x36, 0xF6, 0xF6, 0xE4, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01}, // 6 {0x04, 0x06, 0x06, 0x86, 0xE6, 0xFE, 0x7E, 0x1C 0x00, 0x00, 0x00, 0x01, 0x03, 0x01, 0x00, 0x00}, // 7 {0xCC, 0xFE, 0xFE, 0x36, 0x36, 0xFE, 0xFE, 0xCC, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03 0x0 3, 0x01}, // 8 {0x3C, 0x7E, 0x7E, 0x66, 0x66, 0xFE, 0xFE, 0xFC, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01} // 9};

// კოდები მასივი სიტყვა "TEMP:" სტატიკური const unsigned char TEMP_1 [165] = {0x02, 0x06, 0x06, 0xFE, 0xFE, 0xFE, 0x06, 0x06, 0x02, 0x00, 0xFC, 0xFE, 0xFE, 0x26, 0x26, 0x24, 0x00, 0xFC, 0xFE, 0xFE, 0x1C, 0x38, 0x70, 0x38, 0x1C, 0xFE, 0xFE, 0xFC, 0x00, 0xFC, 0xFE, 0xFE, 0x66, 0x66, 0x7E, 0x7E, 0x3C, 0x00, 0x8C, 0x8C, 0x00, 0x00, 0x00, 0x01, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x03, 0x03, 0x03, 0x01, 0x00, 0x01, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x01, 0x00, 0x01, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x0C, 0x1E, 0x33, 0x33, 0x1E, 0x0C, 0x00, 0xF8, 0xFC, 0x0C, 0x9C, 0x98, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x03, 0x03, 0x01,};

// სიტყვების მასივი "LUX:" const unsigned char TEMP_2 [60] = {0xFC, 0xFE, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0xFE, 0xFC, 0x00, 0x00, 0xFC, 0xFE 0xFC, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01, 0x00, 0x01, 0x03, 0x03, 0x01, 0x00, 0x01, 0x03, 0x03, 0x01, 0x00, 0x01, 0x01};

#ჩართეთ

#ჩართეთ #ჩართეთ

// პორტის ინიციალიზაცია ბათილია Port_Init () {DDRB = (1 << MOSI] | (1 << SCK] | (1 << SS) | (1 << RST] | (1 << DC); // Set MOSI, SCK, SS, RST, DC როგორც გამომავალი, ყველა დანარჩენი შეყვანის PORTB | = (1 << RST]; // დააყენეთ RST pin როგორც მაღალი PORTB | = (1 << SS]; // დააყენეთ SS pin როგორც მაღალი - ჩვენება არის გამორთეთ DDRC = 0xFFu; // დააყენეთ PORTC– ის ყველა ქინძისთავები, როგორც გამომავალი. DDRC & = ~ (1 << 0); // აკეთებს PORTC– ის პირველ პინს, როგორც შეყვანის PORTC = 0x00u; // დააყენეთ PORTC– ის ყველა ქინძისთავი დაბალი, რაც მას გამორთავს. }

// ADC ინიციალიზაცია void ADC_init () {// ADC ჩართვა, შერჩევის სიხშირე = osc_freq/128 დააყენეთ prescaler მაქსიმალური მნიშვნელობა, 128 ADCSRA | = (1 << ADEN) | (1 << ADPS2] | (1 << ADPS1] | (1 << ADPS0]; ADMUX = (1 << REFS0]; // აირჩიეთ ძაბვის მითითება ADC– სთვის // სტანდარტულად აირჩიეთ არხი ნული ADC Multiplexer Select რეგისტრის გამოყენებით (ADC0). }

// ანალოგურ ციფრულზე გადაყვანის ფუნქციის წაკითხვის ფუნქცია uint16_t get_LightLevel () {_delay_ms (10); // დაელოდეთ ცოტა ხანს, სანამ არხი მიიღებს არჩეულ ADCSRA | = (1 << ADSC]; // დაიწყეთ ADC კონვერტაცია ADSC ბიტის დაყენებით. ჩაწერეთ 1 ADSC ხოლო (ADCSRA & (1 << ADSC)); // დაელოდეთ კონვერტაციის დასრულებას // ADSC იქცევა ისევ 0 მანამდე, გაუშვით მარყუჟი მუდმივად _delay_ms (10); დაბრუნება (ADC); // დააბრუნეთ 10-ბიტიანი შედეგი}

// SPI ინიციალიზაცია ბათილია SPI_Init () {SPCR = (1 << SPE] | (1 << MSTR] | (1 << SPR0); // SPI ჩართვა, დაყენება როგორც სამაგისტრო, დააყენეთ პრესკალერი როგორც Fosc/16 SPI კონტროლში რეგისტრაცია}

// ინიციალიზაცია 16 ბიტიანი ტაიმერი 1, შეწყვეტა და ცვლადი void TIMER1_init () {// დააყენეთ ტაიმერი წინასწარგამრიცხველით = 256 და CTC რეჟიმში TCCR1B | = (1 << WGM12] | (1 << CS12); // მრიცხველის ინიციალიზაცია TCNT1 = 0; // შეადარეთ მნიშვნელობის ინიციალიზაცია - 1 წმ OCR1A = 62500; // შეადარეთ შეწყვეტის შედარება TIMSK1 | = (1 << OCIE1A); // გლობალური შეწყვეტის ჩართვა sei (); }

// ჩვენების ჩართვა void SPI_SS_Enable () {PORTB & = ~ (1 << SS); // ჩართეთ SS pin ლოგიკაში 0}

// ჩვენება გამორთვა void SPI_SS_Disable () {PORTB | = (1 << SS]; // გამორთეთ SS პინი ლოგიკაში 1}

// ჩვენების გაგზავნის ფუნქცია ეკრანის ბუფერში void SPI_Tranceiver (ხელმოუწერელი char მონაცემები) {SPDR = მონაცემები; // ჩატვირთეთ მონაცემები ბუფერში, სანამ (! (SPSR & (1 << SPIF))); // დაელოდეთ გადაცემის დასრულებას}

// გადატვირთეთ ჩვენება ინიციალიზაციის დასაწყისში void Display_Reset () {PORTB & = ~ (1 << RST); _ დაგვიანებით_ms (100); PORTB | = (1 << RST]; }

// ბრძანების ჩაწერის ფუნქცია void Display_Cmnd (ხელმოუწერელი char მონაცემები) {PORTB & = ~ (1 << DC); // გააკეთეთ DC pin ლოგიკაში 0 ბრძანების ოპერაციისთვის SPI_Tranceiver (მონაცემები); // მონაცემების გაგზავნა მონაცემთა რეესტრზე PORTB | = (1 << DC); // გადააკეთეთ DC pin ლოგიკური მონაცემების მუშაობისთვის}

// ჩვენების ინიციალიზაცია Display_init () {Display_Reset (); // ეკრანის გადაყენება Display_Cmnd (0x21); // ბრძანება დამატებული რეჟიმში Display_Cmnd (0xC0); // დააყენეთ ძაბვა C0 საშუალებით გაგზავნით VOP = 5V Display_Cmnd (0x07); // დააყენეთ ტემპერატურა. კოეფიციენტი 3 Display_Cmnd (0x13); // ძაბვის მიკერძოების სისტემის ჩვენების მნიშვნელობა_ 0 სმ 20 (0x20); // ბრძანება დაყენებულია ძირითად რეჟიმში Display_Cmnd (0x0C); // შედეგის ჩვენება ნორმალურ რეჟიმში}

// გაასუფთავეთ ჩვენების სიცარიელე Display_Clear () {PORTB | = (1 << DC); // გადააკეთეთ DC პინი ლოგიკამდე მონაცემების ოპერაციისათვის (int k = 0; k <= 503; k ++) {SPI_Tranceiver (0x00);} PORTB & = ~ (1 << DC]; // გააკეთეთ DC pin ლოგიკაში ნულოვანი ბრძანების ოპერაციისთვის}

// დააყენეთ სვეტი და სტრიქონი LCD ეკრანზე შედეგის ჩვენების პოზიციაზე void Display_SetXY (ხელმოუწერელი char x, ხელმოუწერელი char y) {Display_Cmnd (0x80 | x); // სვეტი (0-83) Display_Cmnd (0x40 | y); // რიგი (0-5)}

// უარყოფითი ნიშნის ჩვენების ფუნქცია void Display_Neg (ხელმოუწერელი char neg) {Display_SetXY (41, 0); // ეკრანის პოზიციის მისამართის დაყენება (int index = 0; index0) {SPDR = 0x30;} // მონაცემების ჩატვირთვა ეკრანის ბუფერში (უარყოფითი ნიშნის ჩვენება) სხვაგვარად {SPDR = 0x00;} // მონაცემების ჩატვირთვა ჩვენების ბუფერი (მკაფიო უარყოფითი ნიშანი) ხოლო (! (SPSR & (1 << SPIF))); // დაელოდეთ გადაცემის დასრულებას _ დაგვიანებით_ms (100); }}

// ციფრული ნიშნის ბათილად გამორთვის ფუნქცია Off_Dig (ხელმოუწერელი char x, ხელმოუწერელი char y) {Display_SetXY (x, y); // ეკრანის პოზიციის მისამართის დაყენება (ზედა რიგი) (int index = 0; index <8; index ++) {SPI_Tranceiver (0);} // მონაცემების ჩატვირთვა ეკრანის ბუფერში (ციფრული ნიშნის ზედა ნაწილის გასუფთავება) y ++; Display_SetXY (x, y); // ეკრანის პოზიციის მისამართის დაყენება (ქვედა სტრიქონი) for (int index = 0; index <8; index ++) {SPI_Tranceiver (0);} // მონაცემების ჩატვირთვა ეკრანის ბუფერში (ციფრული ნიშნის ქვედა ქვედა ნაწილი)}

// ციფრული ნიშნის ჩვენების ფუნქცია void Display_Dig (int dig, unsigned char x, unsigned char y) {Display_SetXY (x, y); // ეკრანის პოზიციის მისამართის დაყენება (ზედა რიგი) for (int index = 0; index <16; ინდექსი ++) {if (index == 8) {y ++; Display_SetXY (x, y);} // ეკრანზე პოზიციის მისამართის დაყენება (ქვედა რიგი) SPI_Tranceiver (font6x8 [dig] [index]); // ციფრული მონაცემების მასივის კოდის ჩატვირთვა ჩვენების ბუფერში _delay_ms (10); }}

// DS18B20 ხელმოუწერელი char DS18B20_init () ინიციალიზაცია (DDRD | = (1 << 2); // დააყენეთ PORTD– ის PD2 პინი გამომავალი PORTD & = ~ (1 << 2); // დააყენეთ PD2 პინი დაბალ _delay_us (490); // ინიციალიზაციის დრო DDRD & = ~ (1 << 2); // PORTD– ის PD2 პინის დაყენება, როგორც input _delay_us (68); // დრო OK_Flag = (PIND & (1 << 2)); // მიიღეთ სენსორის პულსი _ დაგვიანებით_us (422); დაბრუნება OK_Flag; // დაბრუნების 0-ok სენსორი არის დანამატი, 1 შეცდომის სენსორი გამორთულია}

// ფუნქცია წაკითხვის ბაიტი DS18B20 unsigned char read_18b20 () {unsigned char i, data = 0; for (i = 0; i <8; i ++) {DDRD | = (1 << 2); // PORTD– ის PD2 პინის დაყენება გამომავალი _delay_us (2); // ვადები DDRD & = ~ (1 1; // შემდეგი ბიტი თუ (PIND & (1 << 2)) მონაცემები | = 0x80; // ბიტი ჩადეთ ბაიტში _delay_us (62);} მონაცემების დაბრუნება;}

// DS18B20– ზე ბაიტის ჩაწერის ფუნქცია void write_18b20 (ხელმოუწერელი char მონაცემები) {unsigned char i; for (i = 0; i <8; i ++) {DDRD | = (1 << 2); // PORTD– ის PD2 პინის დაყენება გამომავალი _delay_us (2); // დრო თუ (მონაცემები & 0x01) DDRD & = ~ (1 << 2); // თუ გვინდა 1 დავწეროთ, გამოუშვით ხაზი სხვა DDRD | = (1 1; // შემდეგი ბიტი _delay_us (62); // დრო DDRD & = ~ (1 << 2); // დააყენეთ PD2 pin PORTD როგორც შეყვანის _ დაგვიანებით_us (2);}}

// სინათლის დონის ჩვენების ფუნქცია void Read_Lux () {uint16_t ბუფერი; ხელმოუწერელი int temp_int_1, temp_int_2, temp_int_3, temp_int_0; // ერთნიშნა, ორნიშნა, სამნიშნა, მეოთხედი ციფრის ბუფერი = get_LightLevel (); // წაიკითხეთ ანალოგურ ციფრულზე გარდაქმნის შუქის დონე temp_int_0 = ბუფერი % 10000 /1000; // მეოთხედი ციფრი temp_int_1 = ბუფერი % 1000 /100; // სამნიშნა რიცხვი temp_int_2 = ბუფერი % 100 /10; // ორნიშნა რიცხვი temp_int_3 = ბუფერი % 10; // ერთნიშნა if (temp_int_0> 0) // თუ შედეგი არის მეოთხედნიშნა რიცხვი {Display_Dig (temp_int_0, 32, 2); // აჩვენეთ სინათლის დონის 1 ციფრი Display_Dig (temp_int_1, 41, 2); // ჩვენება სინათლის დონის 2 ციფრიანი Display_Dig (temp_int_2, 50, 2); // აჩვენეთ სინათლის დონის 3 ციფრი Display_Dig (temp_int_3, 59, 2); // აჩვენეთ სინათლის დონის 4 ციფრი} სხვა {თუ (temp_int_1> 0) // თუ შედეგი არის სამნიშნა რიცხვი {Off_Dig (32, 2); // ნომრის 1 ნიშნის გაწმენდა Display_Dig (temp_int_1, 41, 2); // ჩვენება სინათლის დონის 1 ციფრი Display_Dig (temp_int_2, 50, 2); // ჩვენება სინათლის დონის 2 ციფრიანი Display_Dig (temp_int_3, 59, 2); // აჩვენეთ სინათლის დონის 3 ციფრი} სხვა {თუ (temp_int_2> 0) // თუ შედეგი არის ორნიშნა რიცხვი {Off_Dig (32, 2); // ნომრის 1 ნიშნის გასუფთავება Off_Dig (41, 2); // ნომრის 2 ნიშნის გაწმენდა Display_Dig (temp_int_2, 50, 2); // ჩვენება სინათლის დონის 1 ციფრი Display_Dig (temp_int_3, 59, 2); // აჩვენეთ სინათლის დონის 2 ციფრი} სხვა // თუ შედეგი არის ერთნიშნა რიცხვი {Off_Dig (32, 2); // ნომრის 1 ნიშნის გასუფთავება Off_Dig (41, 2); // ნომრის 2 ნიშნის გასუფთავება Off_Dig (50, 2); // რიცხვის 3 ნიშნის ჩვენება_დიგ (temp_int_3, 59, 2); // აჩვენეთ სინათლის დონის 1 ციფრი}}}}

// ტემპერატურის სიცარიელის ჩვენების ფუნქცია Read_Temp () {unsigned int buffer; ხელმოუწერელი int temp_int_1, temp_int_2, temp_int_3; // ერთნიშნა, ორნიშნა, სამნიშნა, მეოთხედი ციფრის გარეშე ხელმოწერილი char Temp_H, Temp_L, OK_Flag, temp_flag; DS18B20_init (); // DS18B20 write_18b20 (0xCC) ინიციალიზაცია; // სენსორული კოდის შემოწმება write_18b20 (0x44); // ტემპერატურის კონვერტაციის დაწყება _ დაგვიანებით_ms (1000); // სენსორული გამოკითხვის შეფერხება DS18B20_init (); // DS18B20 write_18b20 (0xCC) ინიციალიზაცია; // სენსორული კოდის შემოწმება write_18b20 (0xBE); // ბრძანება წაიკითხოს სენსორის RAM შინაარსი Temp_L = read_18b20 (); // პირველი ორი ბაიტის წაკითხვა Temp_H = read_18b20 (); temp_flag = 1; // 1-დადებითი ტემპერატურა, 0-უარყოფითი ტემპერატურა // მიიღეთ უარყოფითი ტემპერატურა if (Temp_H & (1 << 3)) // Sign Bit Check (თუ ბიტი დაყენებულია-უარყოფითი ტემპერატურა) {ხელმოწერილი int temp; temp_flag = 0; // დროშა დაყენებულია 0 - უარყოფითი ტემპერატურის ტემპერატურა = (Temp_H << 8) | Temp_L; temp = -temp; // გადააკეთეთ დამატებითი კოდი პირდაპირ Temp_L = temp; Temp_H = temp >> 8; } ბუფერი = ((Temp_H 4); temp_int_1 = ბუფერი % 1000 /100; // სამნიშნა რიცხვი temp_int_2 = ბუფერი % 100 /10; // ორნიშნა ნიშანი temp_int_3 = ბუფერი % 10; // ერთნიშნა

// თუ ტემპერატურა არის ტემპერატურის უარყოფითი მაჩვენებელი, სხვა ნათელია

if (temp_flag == 0) {Display_Neg (1);} სხვა {Display_Neg (0);} if (temp_int_1> 0) // თუ შედეგი არის სამნიშნა რიცხვი {Display_Dig (temp_int_1, 45, 0); // აჩვენეთ ტემპერატურის 1 ციფრი Display_Dig (temp_int_2, 54, 0); // აჩვენეთ ტემპერატურის 2 ციფრიანი Display_Dig (temp_int_3, 63, 0); // აჩვენეთ ტემპერატურის 3 ციფრი} else {if (temp_int_2> 0) // თუ შედეგი არის ორნიშნა რიცხვი {Off_Dig (45, 0); // ნომრის 1 ნიშნის გაწმენდა Display_Dig (temp_int_2, 54, 0); // აჩვენეთ ტემპერატურის 1 ციფრი Display_Dig (temp_int_3, 63, 0); // აჩვენეთ ტემპერატურის 2 ციფრი} სხვა // თუ შედეგი არის ერთნიშნა რიცხვი {Off_Dig (45, 0); // ნომრის 1 ნიშნის გასუფთავება Off_Dig (54, 0); // რიცხვის 2 ნიშნის გაწმენდა Display_Dig (temp_int_3, 63, 0); // აჩვენეთ ტემპერატურის 1 ციფრი}}}

// ეს ISR იხსნება ყოველთვის, როდესაც ხდება ტაიმერის რაოდენობის შესატყვისი ღირებულება (ყოველ 1 წამში) ISR (TIMER1_COMPA_vect) {// კითხვა, ტემპერატურის და სინათლის დონის ჩვენება Read_Temp (); Read_Lux (); }

// სიტყვების "TEMP" და "LUX" ჩვენების ფუნქცია void Display_label () {// Word "TEMP" Display_SetXY (0, 0); // ეკრანის პოზიციის მისამართის დაყენება (ზედიზედ მწკრივი) for (int index = 0; index <105; index ++) {if (index == 40) {Display_SetXY (0, 1);} // მითითებული პოზიციის მისამართი ჩვენებაზე (ქვედა სტრიქონი) if (index == 80) {Display_SetXY (72, 0);} // ეკრანის პოზიციის მისამართის დაყენება (ზემოთ რიგი) if (index == 92) {Display_SetXY (72, 1); } // ეკრანის პოზიციის მისამართის დაყენება (ქვედა სტრიქონი) SPDR = TEMP_1 [ინდექსი]; // კოდების მასივის მონაცემების ჩატვირთვა ჩვენების ბუფერში, ხოლო (! (SPSR & (1 << SPIF))); // დაელოდეთ გადაცემის დასრულებას _ დაგვიანებით_ms (10); } // სიტყვა "LUX" Display_SetXY (0, 2); // ეკრანის პოზიციის მისამართის დაყენება (ზედიზედ მწკრივი) (int index = 0; index <60; index ++) {if (index == 30) {Display_SetXY (0, 3);} // პოზიციის მისამართის დაყენება ჩვენებაზე (ქვედა სტრიქონი) SPDR = TEMP_2 [ინდექსი]; // კოდების მასივის მონაცემების ჩატვირთვა ჩვენების ბუფერში, ხოლო (! (SPSR & (1 << SPIF))); // დაელოდეთ გადაცემის დასრულებას _ დაგვიანებით_ms (10); }}

მთავარი (ბათილია)

{პორტი_ნიტი (); // პორტის ინიციალიზაცია ADC_init (); // ADC ინიციალიზაცია SPI_Init (); // SPI ინიციალიზაცია SPI_SS_Enable (); // ჩვენება ჩართვა DS18B20_init (); // DS18B20 Display_init () ინიციალიზაცია; // ჩვენების ინიციალიზაცია Display_Clear (); // მკაფიო ჩვენება Display_label (); // სიტყვების ჩვენება "TEMP" და "LUX" TIMER1_init (); // ტაიმერი 1 ინიციალიზაცია. დაიწყეთ მონიტორინგი. პარამეტრების მიღება ყოველ წამში. // უსასრულობის მარყუჟი while (1) {}}

ნაბიჯი 3: მიკროკონტროლერისთვის პროგრამული უზრუნველყოფის განათება

HEX ფაილის ატვირთვა მიკროკონტროლის ფლეშ მეხსიერებაში. უყურეთ ვიდეოს მიკროკონტროლის ფლეშ მეხსიერების დაწვის დეტალური აღწერით: მიკროკონტროლერის ფლეშ მეხსიერების წვა…

ნაბიჯი 4: მონიტორინგის მოწყობილობა Circuit ასამბლეის

შეაერთეთ კომპონენტები სქემატური დიაგრამის შესაბამისად.

შეაერთეთ დენი და მუშაობს!