AtTiny26简易照度计DIY-LMV772-AtTiny26-S1087-制作DIY

sydz

　　照度是受照平面上接受的光通量的面密度。照度计是用于测量被照面上的光照度的仪器。
　　跟动辄几千元的商用照度计相比，这个成本不足15元的简易照度计，其超值程度可想而知了。
　　这个玩具级的照度计作好以后，我都能想到怎么用，第一件事儿就是拿这个照度计，挨个房间的闯，看看每个房间的照度有什么不同。测过以后呢，不要停，因为关于住宅照明是有标准的。对比一下看看。
　　如果将这个照度计加以扩展，做一个照度记录仪，用来测量自己居室、或者植物温室等特定场所一年四季的光照情况，也是很不错的想法，这些科学数据可以用来进行更加深入的研究。
硬件原理图
　　闲话少扯，先看看这个简易照度计的原理图。
　　其中，以U1 LMV772为核心器件的I-V转换电路将光电管S1087的电流信号转换成电压信号，送入U2 AtTiny26的内置ADC。R5决定了转换系数，为50mV/µA；C5用来增益修正，滤除高频信号。
　　原理图顶部的Q1用来防止电池接反，等效于常进的二极管；Q2、Q3、Q4组成电源开关电路，控制电源的通断。

软件代码
　　软件的主要功能，就是将ADC的读数，经过一定的运算，送入显示器件LED数码管。AD转换器的输入为0 -2.56V，据此推算，可测量的最强光照约30000 lux。开机60秒后，自动关闭电源。

1. /*--------------------------------------------------*/
   
2. /* Lux meter control program (C)ChaN, 2005                        */
   
3. 
   
4. 
   
5. #include <avr/io.h>
   
6. #include <avr/signal.h>
   
7. #include <avr/interrupt.h>
   
8. #include <avr/pgmspace.h>
   
9. #include <avr/eeprom.h>
   
10. #include <string.h>
    
11. #include "xitoa.h"
    
12. 
    
13. #define        SYSCLK                1000000
    
14. 
    
15. /* Bit definition for status flags */
    
16. #define        F_800        (_BV(0))                // 800 Hz timer event
    
17. #define        F_LVD        (_BV(1))                // Low battery
    
18. #define        F_POW        (_BV(2))                // Power event
    
19. #define F_PB        (_BV(3))                // Power button
    
20. 
    
21. 
    
22. 
    
23. 
    
24. /*------------------------------------------------*/
    
25. /* Global variables                               */
    
26. 
    
27. uint8_t Leds[5];                                // LED display buffer
    
28. volatile uint8_t flags;                        // Status flags
    
29. volatile uint16_t OffTimer;                // Auto power off timer
    
30. 
    
31. uint32_t Gain[2];
    
32. uint16_t Ofs20;
    
33. 
    
34. 
    
35. 
    
36. /*------------------------------------------------*/
    
37. /* Interval Timer (800Hz)                         */
    
38. 
    
39. SIGNAL(SIG_OVERFLOW1)
    
40. {
    
41.         static uint8_t bltimer;                // LED blink timer
    
42.         static uint8_t Col;                        // Dynamic scan pointer
    
43. 
    
44. 
    
45.         if(++Col >= sizeof(Leds)) Col = 0;
    
46.         PORTA &= 0b00000100;
    
47.         PORTB = 0;
    
48. 
    
49.         bltimer++;
    
50.         if((bltimer & 7) == 0) {        // Check power button every 8 (100/sec)
    
51.                 PORTA |= _BV(3);
    
52.                 DDRA &= ~_BV(3);
    
53.                 DDRA &= ~_BV(3);
    
54.                 DDRA &= ~_BV(3);
    
55.                 if(PINA & _BV(3)) {
    
56.                         flags |= F_PB;
    
57.                 } else {
    
58.                         if(flags & F_PB)
    
59.                                 flags |= F_POW;
    
60.                         flags &= ~F_PB;
    
61.                 }
    
62.                 PORTA &= 0b00000100;
    
63.                 DDRA |= _BV(3);
    
64.         }
    
65.         if((bltimer & 0xC0) || !(flags & F_LVD))        // Blink control
    
66.                 PORTB = Leds[Col];
    
67.         PORTA |= (0b00001000 << Col);
    
68. 
    
69.         if(--OffTimer == 0) flags |= F_POW;                        // Auto power-off timer
    
70. 
    
71.         flags |= F_800;
    
72. }
    
73. 
    
74. 
    
75. 
    
76. /* Character output function for LED display (called by xitoa module) */
    
77. 
    
78. void putled(char c)
    
79. {
    
80.         static uint8_t wp;        // Write index
    
81.         static const prog_uint8_t seg7[]        // Segment pattern
    
82.                 = {0x7E, 0x30, 0x6D, 0x79, 0x33, 0x5B, 0x5F, 0x70, 0x7F, 0x7B, 0};
    
83. 
    
84. 
    
85.         if(c == '\r') {                // Return index to left
    
86.                 wp = 0;
    
87.                 return;
    
88.         }
    
89.         c -= '0';                        // Put a segment pattern into display buffer
    
90.         if((uint8_t)c > 9) c = 10;
    
91.         Leds[wp++] = pgm_read_byte(&seg7[(uint8_t)c]);
    
92. }
    
93. 
    
94. 
    
95. 
    
96. void delay (uint16_t dly)
    
97. {
    
98.         do {
    
99.                 cli(); flags &= ~F_800; sei();
    
100.                 while((flags & F_800) == 0);
     
101.         } while(--dly);
     
102. }
     
103. 
     
104. 
     
105. 
     
106. uint16_t adconv(uint8_t ch)
     
107. {
     
108.         ADMUX = ch;
     
109.         ADCSR = 0b11010011;
     
110.         while(bit_is_clear(ADCSR, ADIF));
     
111.         return ADC;
     
112. }
     
113. 
     
114. 
     
115. 
     
116. /*------------------------------------------------*/
     
117. /* Main Process                                   */
     
118. 
     
119. 
     
120. int main(void)
     
121. {
     
122.         uint16_t n, d;
     
123.         uint32_t v, u;
     
124. 
     
125. 
     
126.         /* Initialize ports */
     
127.         PORTA = 0b00000100;
     
128.         DDRA  = 0b11111110;
     
129. 
     
130.         PORTB = 0b00000101;
     
131.         DDRB  = 0b01111111;
     
132. 
     
133.         /* Start TC1 with 800Hz OC-A */
     
134.         OCR1C = SYSCLK/8/800-1;
     
135.         TCCR1B = _BV(CTC1) | 0b0100;
     
136.         TIMSK = _BV(TOIE1);
     
137. 
     
138.         eeprom_read_block(Gain, 0, sizeof(Gain));
     
139. 
     
140.         xfunc_out = putled;                // Join xitoa molule and my output function
     
141. 
     
142.         OffTimer = 48000;        // Auto power off timer (60sec)
     
143. 
     
144.         sei();
     
145. 
     
146.         /* Lamp test */
     
147.         memset(Leds, 0x7F, sizeof(Leds));
     
148.         delay(400);
     
149. 
     
150. 
     
151.         delay(10);
     
152.         Ofs20 = adconv(0x80 + 13);
     
153.         delay(10);
     
154. 
     
155. 
     
156.         cli();
     
157.         PORTA &= 0b00000100;
     
158.         PORTB = 0b00000101;
     
159.         DDRB  = 0b01111010;
     
160.         DDRB  = 0b01111010;
     
161.         DDRB  = 0b01111010;
     
162. 
     
163.         /* MOSI is tied to GND. Low range calibration (1250 lux at -100 mV) */
     
164.         if((PINB & _BV(0)) == 0) {
     
165.                 adconv(0x80 + 11);
     
166.                 Gain[0] = 1250 * 65536 / (uint32_t)(adconv(0x80 + 11) - Ofs20);
     
167.                 eeprom_write_block(Gain, 0, sizeof(Gain));
     
168.                 Leds[0] = 0;
     
169.         }
     
170. 
     
171.         /* SCK is tied to GND. High range calibration (12500 lux at -1 V) */
     
172.         if((PINB & _BV(2)) == 0) {
     
173.                 adconv(0x80 + 0);
     
174.                 Gain[1] = 12500 * 65536 / (uint32_t)(adconv(0x80 + 0));
     
175.                 eeprom_write_block(Gain, 0, sizeof(Gain));
     
176.                 Leds[1] = 0;
     
177.         }
     
178. 
     
179.         DDRB =  0b01111111;
     
180.         sei();
     
181. 
     
182. 
     
183.         /* Measurement loop continued until any power event occure */
     
184. 
     
185.         while(!(flags & F_POW)) {
     
186.                 v = 0;
     
187.                 for(n = 0; n < 256; n++)        // 256 times averaging to filter-out flicker
     
188.                 {
     
189.                         d = adconv(0x80 + 11);
     
190.                         while(!(flags & F_800));
     
191.                         cli(); flags &= ~F_800; sei();
     
192.                         d = adconv(0x80 + 11);
     
193.                         if(d < 1023) {
     
194.                                 d -= Ofs20;
     
195.                                 u = Gain[0];
     
196.                         } else {
     
197.                                 d = adconv(0x80 + 0);
     
198.                                 u = Gain[1];
     
199.                         }
     
200.                         d = (u * (uint32_t)d) >> 16;
     
201.                         v += d;
     
202.                 }
     
203. 
     
204.                 /* Refresh lux value */
     
205.                 xputc('\r');
     
206.                 xitoa(v / 256, 10, 5);
     
207. 
     
208.                 /* Check battrey voltage */
     
209.                 DDRA &= ~_BV(1);
     
210.                 d = adconv(0x80 + 1);
     
211.                 cli();
     
212.                 if(d >= 23)
     
213.                         flags &= ~F_LVD;
     
214.                 else
     
215.                         flags |= F_LVD;
     
216.                 sei();
     
217.                 DDRA |= _BV(1);
     
218.         }
     
219. 
     
220. 
     
221.         /* Power off */
     
222.         memset(Leds, 0, sizeof(Leds));        // Clear display
     
223.         PORTA &= ~_BV(2);                                // Release power hold
     
224.         for(;;);
     
225. }
     
226. 
     

复制代码

C程序.zip (54.74 KB, 下载次数: 24)

2011-10-15 22:31 上传

点击文件名下载附件

◤奋斗◥

顶贴  强烈支持一下