צג טמפרטורה ורמת אור עם תצוגה על LCD NOKIA 5110: 4 שלבים

2024 מְחַבֵּר: John Day | [email protected]. שונה לאחרונה: 2024-01-30 09:15

שלום לכולם!

בחלק זה אנו מייצרים מכשיר אלקטרוני פשוט לניטור הטמפרטורה ורמת האור. מדידות של פרמטרים אלה מוצגות ב- LCD NOKIA 5110. המכשיר מבוסס על המיקרו -בקר AVR ATMEGA328P. מכשיר הניטור מצויד במדחום דיגיטלי DS18B20 ובפוטורסיסטור למדידת רמת האור.

שלב 1: רכיבי תיאור

רכיבים בסיסיים של מכשיר הניטור:

• מיקרו -בקר AVR «ATMEGA328P»
• מסך גרפי מונוכרום «NOKIA 5110»
• רזולוציה לתכנות מדחום דיגיטלי חד-חוטי «DS18B20»
• נגד תלוי אור
• חוטים

מיקרו -בקר AVR «ATMEGA328P»

מכשיר הניטור משתמש בתכונות ההיקפיות הבאות של המיקרו -בקר:

1. הפרעה של טיימר/מונה 16 סיביות
2. ADC בעל 8 ערוצים 10 סיביות
3. ממשק סידורי של Master/slave SPI

מסך גרפי מונוכרום «NOKIA 5110»

מפרטים:

1. תצוגת LCD בגודל 48 x 84 נקודות
2. ממשק אוטובוס סידורי במהירות מירבית גבוהה של 4 Mbits/S
3. בקר/נהג פנימי «PCD8544»
4. תאורה אחורית LED
5. הפעל במתח 2.7-5 וולט
6. צריכת חשמל נמוכה; הוא מתאים ליישומי סוללה
7. טווח טמפרטורות מ -25 ˚ עד +70 ˚
8. תמיכת קלט CMOS לאות

טיפול בכתובת LCD (כתובת):

סידור הכתובת של הזיכרון המוצג בתצוגת LCD (DDRAM) הוא מטריצה הכוללת 6 שורות (כתובת Y) מכתובת Y עד כתובת Y 5 ו -84 עמודות (כתובת X) מכתובת X ל- X- כתובת 83. אם המשתמש רוצה לגשת למיקום של הצגת התוצאה בתצוגת LCD, עליו להתייחס למערכת היחסים בין כתובת X לבין כתובת Y.

הנתונים שיישלחו לתצוגה הם 8 ביט (1 בייט) והוא יסודר כקו אנכי; במקרה זה, Bit MSB יהיה נמוך יותר ו- Bit LSB יהיה עליון כפי שמוצג בתמונה.

רזולוציה לתכנות מדחום דיגיטלי חד-חוטי 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 סיביות המאוחסן ב- ROM המשולב
10. הגדרות אזעקה גמישות להגדרות משתמש (NV) עם פקודת חיפוש אזעקות מזהות מכשירים עם טמפרטורות מחוץ למגבלות מתוכנתות

יישומים:

1. פקדים תרמוסטטיים
2. מערכות תעשייתיות
3. מוצרי צריכה
4. מד חום
5. מערכות רגישות תרמית

נגד תלוי אור

התנגדות תלויה באור (LDR) היא מתמר המשנה את התנגדותו כאשר אור נופל על פני השטח שלו משתנה.

בדרך כלל ל- LDR יהיה מגה -אוהם אחד לשני מגאו -אוהם בחושך מוחלט, מעשרה לעשרים קילו -אוהם בעשרה LUX, משניים עד חמישה קילו -אוהם ב -100 LUX. ההתנגדות בין שני המגעים של החיישן יורדת עם עוצמת האור או שהמוליכות בין שני המגעים של החיישן עולה.

השתמש במעגל מחלק מתח כדי להמיר שינוי בהתנגדות לשינוי במתח.

שלב 2: קוד קושחה של מיקרו -בקר

#ifndef F_CPU #הגדר F_CPU 16000000UL // מספר תדר קריסטל בקר (16 MHz AVR ATMega328P) #endif

// SPI INTERFACE DEFINES #הגדר MOSI 3 // MOSI זה יציאה B, PIN 3 #הגדר MISO 4 // MISO זה יציאה B, PIN 4 #הגדר SCK 5 // SCK זה יציאה B, PIN 5 #הגדר SS 2 // SS זה יציאה B, PIN 2

// אפס את התצוגה #הגדר RST 0 // אפס את יציאת B, PIN 0

// בחירת מצב תצוגה - קלט לבחירת פקודה/כתובת או קלט נתונים. #define DC 1 // DC זה יציאה B, PIN 1

// מערך קודים של שלילי סימן שלילי const uns uns char [4] = {0x30, 0x30, 0x30, 0x30};

// מערך קודים של ספרות [0..9] סטטי const unsigned 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, 0x00}, // 1 { 0x0C, 0x8E, 0xCE, 0xE6, 0xE6, 0xBE, 0x9E, 0x0C, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01}, // 2 {0x00, 0x04, 0x06, 0x0,, 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 { 0xFE, 0xFE, 0x36, 0x36, 0xF6, 0xF6, 0xE4, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01}, // 6 {0x04, 0x06, 0x06, 0x6, 0x6, 0xE, 0x00, 0x00, 0x00, 0x01, 0x03, 0x01, 0x00, 0x00}, // 7 {0xCC, 0xFE, 0xFE, 0x36, 0x36, 0xFE, 0xFE, 0xCC, 0x01, 0x03, 0x03, 0x0, 0x0, 0x0 3, 0x01}, // 8 {0x3C, 0x7E, 0x7E, 0x66, 0x66, 0xFE, 0xFE, 0xFC, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01} // 9};

// מערך קודים של המילה "TEMP:" char static uns 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, 0x7, 0x8, 0x8 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, 0x0, 0x, 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, 0x00, 0x04, 0x8E, 0xDE, 0xFC, 0xF8, 0xFC, 0xDE, 0x8E, 0x04, 0x00, 0x8C, 0x8C, 0x01, 0x03, 0x03, 0x03, 0x03, 0x0, 0x0, 0x0, 0x0, 0x3, 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); // הגדר MOSI, SCK, SS, RST, DC כפלט, כל שאר הקלט PORTB | = (1 << RST); // הגדר סיכת RST כגבוה PORTB | = (1 << SS); // הגדר סיכת SS כגבוהה - הצג הוא השבת DDRC = 0xFFu; // הגדר את כל הסיכות של ה- PORTC כפלט. DDRC & = ~ (1 << 0); // עושה סיכה ראשונה של PORTC כקלט PORTC = 0x00u; // הגדר את כל סיכות ה- PORTC נמוכות מה שמכבה אותו. }

// ADC Initialization void ADC_init () {// אפשר ADC, freq sample = osc_freq/128 הגדר prescaler לערך מקסימלי, 128 ADCSRA | = (1 << ADEN) | (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0); ADMUX = (1 << REFS0); // בחר את התייחסות המתח עבור ה- ADC // בחר ערוץ אפס כברירת מחדל באמצעות רשם הבחירה מרובי ADC (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_Init initial void SPI_Init () {SPCR = (1 << SPE) | (1 << MSTR) | (1 << SPR0); // הפעל SPI, הגדר כמאסטר, הגדר מראש כיסוי כ- Fosc/16 בבקרת SPI הירשם }

// לאתחל טיימר 16 ביט, הפרעה ומשתנה חלל TIMER1_init () {// הגדר טיימר עם prescaler = 256 ומצב CTC TCCR1B | = (1 << WGM12) | (1 << CS12); // לאתחל מונה TCNT1 = 0; // לאתחל ערך השוואה - 1 שניות OCR1A = 62500; // אפשר השווה להפריע TIMSK1 | = (1 << OCIE1A); // לאפשר הפרעות גלובליות sei (); }

// הצג אפשר חלל SPI_SS_Enable () {PORTB & = ~ (1 << SS); // אפשר את סיכת ה- SS ללוגיקה 0}

// Display Disable void SPI_SS_Disable () {PORTB | = (1 << SS); // השבת את סיכת ה- SS להיגיון 1}

// פונקציה לשליחת נתונים לחלל מאגר התצוגה SPI_Tranceiver (נתוני צ'אר לא חתומים) {SPDR = data; // טען נתונים למאגר בעוד (! (SPSR & (1 << SPIF))); // המתן עד להשלמת השידור}

// אפס את התצוגה בתחילת האתחול חלל Display_Reset () {PORTB & = ~ (1 << RST); _ delay_ms (100); PORTB | = (1 << RST); }

// פונקציית כתיבת הפקודה void Display_Cmnd (נתוני char לא חתומים) {PORTB & = ~ (1 << DC); // להפוך את סיכת DC ללוגיקה 0 לפעולת הפקודה SPI_Tranceiver (נתונים); // לשלוח נתונים על רישום הנתונים PORTB | = (1 << DC); // להפוך את סיכת DC ללוגיקה גבוהה להפעלת נתונים}

// אתחול של Display_init ()_ Display_Reset () ריק של Display Display (); // אפס את התצוגה Display_Cmnd (0x21); // פקודה מוגדרת במצב הוספת Display_Cmnd (0xC0); // הגדר את המתח על ידי שליחת C0 פירושו VOP = 5V Display_Cmnd (0x07); // הגדר את הטמפ '. מקדם ל -3 Display_Cmnd (0x13); // ערך מוגדר של מתח הטיית מערכת Display_Cmnd (0x20); // פקודה מוגדרת במצב בסיסי Display_Cmnd (0x0C); // הצגת תוצאה במצב רגיל}

// נקה את חלל התצוגה Display_Clear () {PORTB | = (1 << DC); // הפוך את סיכת DC ללוגיקה גבוהה עבור פעולת הנתונים עבור (int k = 0; k <= 503; k ++) {SPI_Tranceiver (0x00);} PORTB & = ~ (1 << DC); // הפוך סיכה DC להיגיון אפס לפעולת הפקודה}

// הגדר את העמודה והשורה למיקום של הצגת התוצאה על תצוגת LCD חלל Display_SetXY (תו x לא חתום, תו לא חתום) {Display_Cmnd (0x80 | x); // עמודה (0-83) Display_Cmnd (0x40 | y); // שורה (0-5)}

// פונקציה להצגת סימן שלילי חלל Display_Neg (תו לא חתום) {Display_SetXY (41, 0); // הגדר את כתובת המיקום המוצג עבור (int index = 0; index0) {SPDR = 0x30;} // טען נתונים למאגר התצוגה (סימן שלילי לתצוגה) אחר {SPDR = 0x00;} // טען נתונים לתוך מאגר התצוגה (סימן שלילי ברור) בעוד (! (SPSR & (1 << SPIF))); // המתן עד שהשידור יסתיים _מסך_מס (100); }}

// פונקציה לניקוי הסימן הדיגיטלי חלל Off_Dig (תו x לא חתום, תו לא חתום) {Display_SetXY (x, y); // הגדר את כתובת המיקום המוצג (השורה העליונה) עבור (int index = 0; index <8; index ++) {SPI_Tranceiver (0);} // טען נתונים למאגר התצוגה (חלק עליון ברור של השלט הדיגיטלי) y ++; Display_SetXY (x, y); // הגדר את כתובת המיקום בתצוגה (בשורה התחתונה) עבור (int index = 0; index <8; index ++) {SPI_Tranceiver (0);} // טען נתונים במאגר התצוגה (חלק תחתון ברור של השלט הדיגיטלי)}

// פונקציה להצגת סימן דיגיטלי חלל Display_Dig (int dig, uns x ללא סימן, תו לא חתום) {Display_SetXY (x, y); // הגדר את כתובת המיקום המוצג (השורה העליונה) עבור (int index = 0; index <16; index ++) {if (index == 8) {y ++; Display_SetXY (x, y);} // הגדר את כתובת המיקום המוצגת (בשורה התחתונה) SPI_Tranceiver (font6x8 [dig] [index]); // טען מערך קודים של נתוני ספרות לתוך המאגר של _delay_ms תצוגה (10); }}

// אתחול DS18B20 char un sign DS18B20_init () {DDRD | = (1 << 2); // הגדר את סיכת PD2 של ה- PORTD כפלט PORTD & = ~ (1 << 2); // הגדר את סיכת PD2 כ- _עיכוב_ נמוך (490); // תזמון אתחול DDRD & = ~ (1 << 2); // הגדר את סיכת PD2 של ה- PORTD כקלט _עיכוב_אוס (68); // תזמון OK_Flag = (PIND & (1 << 2)); // לקבל דופק חיישן _עיכוב_אוס (422); החזר OK_Flag; // החזר 0-ok חיישן הוא תקע, חיישן 1 שגיאה ניתוק}

// פונקציה לקריאת בתים מ- DS18B20 char לא חתום read_18b20 () {un Charged i, data = 0; עבור (i = 0; i <8; i ++) {DDRD | = (1 << 2); // הגדר את סיכת PD2 של ה- PORTD כפלט _עיכוב_אוס (2); // תזמון DDRD & = ~ (1 1; // סיביה הבאה אם (PIND & (1 << 2)) נתונים | = 0x80; // הכנס ביט לביט _ delay_us (62);} החזר נתונים;}

// פונקציה לכתיבת בתים ל- DS18B20 void write_18b20 (נתוני char שאינם חתומים) {uns i char i; עבור (i = 0; i <8; i ++) {DDRD | = (1 << 2); // הגדר את סיכת PD2 של ה- PORTD כפלט _עיכוב_אוס (2); // תזמון אם (נתונים & 0x01) DDRD & = ~ (1 << 2); // אם נרצה לכתוב 1, שחרר את השורה אחרת DDRD | = (1 1; // bit next _delay_us (62); // תזמון DDRD & = ~ (1 << 2); // הגדר סיכת PD2 של ה- PORTD כקלט _delay_us (2);}}

// פונקציה להצגת חלל ברמת האור Read_Lux () {uint16_t buffer; 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; // חד ספרתי אם (temp_int_0> 0) // אם התוצאה היא מספר רבעוני {Display_Dig (temp_int_0, 32, 2); // הצג ספרה אחת של רמת אור Display_Dig (temp_int_1, 41, 2); // להציג 2 ספרות ברמת אור Display_Dig (temp_int_2, 50, 2); // להציג 3 ספרות ברמת אור Display_Dig (temp_int_3, 59, 2); // להציג 4 ספרות של רמת אור} אחר {if (temp_int_1> 0) // אם התוצאה היא מספר תלת ספרתי {Off_Dig (32, 2); // נקה סימן אחד של המספר Display_Dig (temp_int_1, 41, 2); // להציג ספרה אחת של רמת אור Display_Dig (temp_int_2, 50, 2); // להציג 2 ספרות ברמת אור Display_Dig (temp_int_3, 59, 2); // להציג 3 ספרות של רמת אור} אחר {if (temp_int_2> 0) // אם התוצאה היא מספר דו ספרתי {Off_Dig (32, 2); // נקה סימן אחד של מספר Off_Dig (41, 2); // נקה סימן 2 למספר Display_Dig (temp_int_2, 50, 2); // הצג ספרה אחת של רמת אור Display_Dig (temp_int_3, 59, 2); // להציג 2 ספרות של רמת אור} אחרת // אם התוצאה היא מספר חד ספרתי {Off_Dig (32, 2); // נקה סימן אחד של מספר Off_Dig (41, 2); // נקה 2 סימן של מספר Off_Dig (50, 2); // נקה 3 סימן המספר Display_Dig (temp_int_3, 59, 2); // הצג ספרה אחת של רמת אור}}}}

// פונקציה להצגת טמפרטורת חלל Read_Temp () {מאגר int לא חתום; 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); // התחל המרת טמפרטורה _עיכוב_מס (1000); // עיכוב בסקר חיישן DS18B20_init (); // אתחול DS18B20 write_18b20 (0xCC); // בדיקת קוד חיישן write_18b20 (0xBE); // פקודה לקרוא את התוכן של חיישן RAM Temp_L = read_18b20 (); // קרא את שני הבייט הראשון Temp_H = read_18b20 (); temp_flag = 1; // טמפרטורה 1-חיובית, 0-טמפרטורה שלילית // קבל טמפרטורה שלילית אם (Temp_H & (1 << 3)) // Sign Bit Check (אם הסיביט מוגדר-טמפרטורה שלילית) {sign 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);} else {Display_Neg (0);} if (temp_int_1> 0) // אם התוצאה היא מספר תלת ספרתי {Display_Dig (temp_int_1, 45, 0); // להציג ספרה אחת של טמפרטורה Display_Dig (temp_int_2, 54, 0); // להציג 2 ספרות של טמפרטורה Display_Dig (temp_int_3, 63, 0); // הצג 3 ספרות של טמפרטורה} אחר {if (temp_int_2> 0) // אם התוצאה היא מספר דו ספרתי {Off_Dig (45, 0); // נקה סימן אחד של המספר Display_Dig (temp_int_2, 54, 0); // להציג ספרה אחת של טמפרטורה Display_Dig (temp_int_3, 63, 0); // להציג 2 ספרות של טמפרטורה} אחרת // אם התוצאה היא מספר חד ספרתי {Off_Dig (45, 0); // נקה סימן אחד של מספר Off_Dig (54, 0); // נקה 2 סימן מספר Display_Dig (temp_int_3, 63, 0); // הצג ספרה אחת של טמפרטורה}}}

// ISR זה מופעל בכל פעם שמתרחשת התאמה של ספירת טיימר עם ערך השוואה (כל שנייה אחת) ISR (TIMER1_COMPA_vect) {// קריאה, הצגת טמפרטורה ורמת אור Read_Temp (); Read_Lux (); }

// פונקציה להצגת המילים "TEMP" ו- "LUX" חלל Display_label () {// Word "TEMP" Display_SetXY (0, 0); // הגדר את כתובת המיקום המוצג (שורה למעלה) עבור (int index = 0; index <105; index ++) {if (index == 40) {Display_SetXY (0, 1);} // הגדר את כתובת המיקום בתצוגה (בשורה התחתונה) אם (index == 80) {Display_SetXY (72, 0);} // הגדר את כתובת המיקום בתצוגה (שורה למעלה) אם (index == 92) {Display_SetXY (72, 1); } // הגדר את כתובת המיקום בתצוגה (בשורה התחתונה) SPDR = TEMP_1 [אינדקס]; // טען נתוני מערך קודים למאגר התצוגה תוך (! (SPSR & (1 << SPIF))); // המתן עד להשלמת השידור _מסך_מס (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))); // המתן עד להשלמת ההעברה _מסך_מס (10); }}

int main (void)

{Port_Init (); // אתחול יציאות ADC_init (); // אתחול ADC SPI_Init (); // אתחול SPI_SS_Enable (); // הצג אפשר DS18B20_init (); // אתחול DS18B20 Display_init (); // אתחול התצוגה Display_Clear (); // הצג תווית תצוגה ברורה (); // הצג מילים "TEMP" ו- "LUX" TIMER1_init (); // אתחול טיימר 1. התחל במעקב. קבלת פרמטרים כל שנייה. // לולאת אינסוף בעוד (1) {}}

שלב 3: מהבהבת קושחה למיקרו -בקר

העלאת קובץ HEX לזיכרון הבזק של המיקרו -בקר. צפה בסרטון עם תיאור מפורט של צריבת זיכרון ההבזק של המיקרו -בקר: צריבת זיכרון הבזק של מיקרו -בקר …

שלב 4: מעקב אחר מכלול מעגל ההתקן

חבר רכיבים בהתאם לתרשים סכמטי.

תקע חשמל וזה עובד!