1 | #define F_CPU 3686400
|
2 | #include <avr\io.h>
|
3 | void lcdWrite(char* pText);
|
4 | uint8_t twiAdr=0x90; // Feste und Variable (per Jumper) Adresse
|
5 | #define BAUD 9600
|
6 | //---------------------------------------------------------------------------------
|
7 | // TWI-Funktionssammlung
|
8 | //---------------------------------------------------------------------------------
|
9 | #ifndef TWI_CLOCK
|
10 | #define TWI_CLOCK 100000 // Geschwindigkeit des TWI-Busses
|
11 | #endif
|
12 | // TWCR - Control-Register-Bits
|
13 | #define _TWINT 0b10000000
|
14 | #define _TWEA 0b01000000
|
15 | #define _TWSTA 0b00100000
|
16 | #define _TWSTO 0b00010000
|
17 | #define _TWWC 0b00001000
|
18 | #define _TWEN 0b00000100
|
19 | #define _TWIE 0b00000001
|
20 | #define REG_LM75_TEMP 0b00000000
|
21 | #define REG_LM75_CONFIG 0b00000001
|
22 | #define REG_LM75_HYST 0b00000010
|
23 | #define REG_LM75_SET 0b00000011
|
24 | #ifndef TWI_READ
|
25 | #define TWI_READ 0b00000001
|
26 | #endif
|
27 | #ifndef TWI_WRITE
|
28 | #define TWI_WRITE 0b00000000
|
29 | #endif
|
30 | #include <util\delay.h>
|
31 |
|
32 | //----------------------------------------------------------------------
|
33 | // Titel : C-Funktion Zeichen zu UART senden.
|
34 | //----------------------------------------------------------------------
|
35 | // Funktion : ...
|
36 | // IN : char data
|
37 | // OUT : ...
|
38 | //----------------------------------------------------------------------
|
39 | void uartPutChar(char data)
|
40 | {
|
41 | //warte bis UDR leer ist UCSRA / USR bei z.B.: 2313
|
42 | while (!(UCSRA&32));
|
43 | //sende
|
44 | UDR=data;
|
45 | }
|
46 | //----------------------------------------------------------------------
|
47 | // Titel : C-Funktion Zeichen von UART holen.
|
48 | //----------------------------------------------------------------------
|
49 | // Funktion : ...
|
50 | // IN : ...
|
51 | // OUT : data
|
52 | //----------------------------------------------------------------------
|
53 | char uartGetChar()
|
54 | {
|
55 | char data=0;
|
56 | //warte bis RX-complete RXC UCSRA / USR bei z.B.: AT090S2313
|
57 | while (!(UCSRA&128));
|
58 | //empfangen
|
59 | data=UDR;
|
60 | return data;
|
61 | }
|
62 | //----------------------------------------------------------------------
|
63 | // Titel : C-Funktion Zeichenkette zu UART senden.
|
64 | //----------------------------------------------------------------------
|
65 | // Funktion : ...
|
66 | // IN : char *buffer, Zeichenkette mit NUll abgeschlossen
|
67 | // OUT : ...
|
68 | //----------------------------------------------------------------------
|
69 | void uartPutString(char *buffer)
|
70 | {
|
71 | for (int i=0; buffer[i] !=0;i++)
|
72 | uartPutChar (buffer[i]);
|
73 | }
|
74 |
|
75 | //------------------------------------------------------------------------
|
76 | // twiInitMaster
|
77 | //------------------------------------------------------------------------
|
78 | void twiInitMaster(uint8_t twiAdr)
|
79 | {
|
80 | // Clock
|
81 | TWBR=((F_CPU/TWI_CLOCK)-16)*2;
|
82 | // TWI-Status-Register (Vorteiler)
|
83 | TWSR=0;
|
84 | // Bus-Addr
|
85 | TWAR=twiAdr;
|
86 | // Enable
|
87 | TWCR=_TWINT|_TWEN;
|
88 | }
|
89 | //------------------------------------------------------------------------
|
90 | // Start TWI (ohne Interrupt)
|
91 | //------------------------------------------------------------------------
|
92 | void twiStart()
|
93 | {
|
94 | uint8_t x=TWCR;
|
95 | x&=_TWEN|_TWIE; // nur Beibehalten von Enable und InterruptJ/N
|
96 | TWCR=x|_TWINT|_TWSTA;
|
97 | // warten bis fertig
|
98 | while( !(TWCR & _TWINT))
|
99 | {}
|
100 | }
|
101 | //------------------------------------------------------------------------
|
102 | // Stopp TWI (ohne Interrupt)
|
103 | //------------------------------------------------------------------------
|
104 | void twiStop()
|
105 | {
|
106 | uint8_t x=TWCR;
|
107 | x&=_TWEN|_TWIE; // nur Beibehalten von Enable und InterruptJ/N
|
108 | TWCR=x|_TWINT|_TWSTO;
|
109 | }
|
110 | //------------------------------------------------------------------------
|
111 | // Write Byte per TWI (ohne Interrupt)
|
112 | // PE: data = zu sendende Daten
|
113 | // ackn = wenn !=0 wird Acknowledge (=TWEA) gesetzt
|
114 | //------------------------------------------------------------------------
|
115 | void twiWriteByte(uint8_t data, uint8_t ackn)
|
116 | {
|
117 | TWDR=data; // Daten bereitlegen
|
118 | // Befehl zusammenstellen
|
119 | uint8_t x=TWCR;
|
120 | x&=_TWEN|_TWIE; //nur Beibehalten von Enable und InterruptJ/N
|
121 | x|=_TWINT;
|
122 | if(ackn)
|
123 | x|=_TWEA; // evt. TWEA setzen, für Datenanforderung
|
124 | TWCR=x; // senden
|
125 | // warten bis fertig
|
126 | while( !(TWCR & _TWINT))
|
127 | {}
|
128 | }
|
129 | //------------------------------------------------------------------------
|
130 | // Read Byte per TWI (ohne Interrupt)
|
131 | // PE: ackn = wenn !=0 wird Acknowledge (=TWEA) gesetzt
|
132 | // PA: Data
|
133 | //------------------------------------------------------------------------
|
134 | int twiReadByte(uint8_t ackn)
|
135 | {
|
136 | // Befehl zusammenstellen
|
137 | uint8_t x=TWCR;
|
138 | x&=_TWEN|_TWIE; //nur Beibehalten von Enable und InterruptJ/N
|
139 | x|=_TWINT;
|
140 | if(ackn)
|
141 | x|=_TWEA; // evt. TWEA setzen, für Datenanforderung
|
142 | TWCR=x; // senden
|
143 | // warten bis fertig
|
144 | while( !(TWCR & _TWINT))
|
145 | {}
|
146 | return TWDR;
|
147 | }
|
148 |
|
149 | //------------------------------------------------------------------------
|
150 | // lm75SetRegister - schreibt ein Register des LM75
|
151 | // PE: twiAdr = TWI-Adresse der LM75
|
152 | // Register = REG_CONFIG,REG_HYST,REG_SET
|
153 | // lowData,highData = zu schreibende Werte
|
154 | //------------------------------------------------------------------------
|
155 | void lm75SetRegister(uint8_t twiAdr,uint8_t reg, uint8_t highData, uint8_t lowData)
|
156 | {
|
157 | twiStart();
|
158 | //Adresse senden
|
159 | twiWriteByte((twiAdr&0xfe)|TWI_WRITE,0); // kein ACKN
|
160 | //Register adressieren
|
161 | twiWriteByte(reg,0); // kein ACKN
|
162 | //Wert schreiben
|
163 | twiWriteByte(highData,0); // kein ACKN
|
164 | //Wert schreiben
|
165 | twiWriteByte(lowData,0); // kein ACKN
|
166 | // Stopp
|
167 | twiStop();
|
168 |
|
169 | }
|
170 | //------------------------------------------------------------------------
|
171 | // Init
|
172 | // PE: twiAdr = TWI-Adresse der LM75
|
173 | //------------------------------------------------------------------------
|
174 | void lm75Init(uint8_t twiAdr, uint8_t compTemp=0,uint8_t compTempHalf=0)
|
175 | {
|
176 | // Config = NoShutdown,ComperatorMode,ActiveLow,FaultQueue=0
|
177 | lm75SetRegister(twiAdr,REG_LM75_CONFIG,0,0);
|
178 | // keine Hysterese
|
179 | lm75SetRegister(twiAdr,REG_LM75_HYST,0,0);
|
180 | // Comperator-PIN schaltet z.B. bei = 0x1C = 28 C
|
181 | lm75SetRegister(twiAdr,REG_LM75_SET,compTemp,compTempHalf);
|
182 | }
|
183 | //------------------------------------------------------------------------
|
184 | // Liest die aktuelle Temperatur
|
185 | // PE: twiAdr = TWI-Adresse der LM75
|
186 | // PA: Temperatur in Grad
|
187 | //------------------------------------------------------------------------
|
188 | uint8_t lm75GetTempGrad(uint8_t twiAdr)
|
189 | {
|
190 | // TWI starten
|
191 | twiStart();
|
192 | // Adresse senden
|
193 | twiWriteByte((twiAdr&0xfe)|TWI_WRITE,0); // kein ACKN
|
194 | // Temperatur adressieren
|
195 | twiWriteByte(REG_LM75_TEMP,0); // kein ACKN
|
196 |
|
197 | //--- Lesezyklus
|
198 | // TWI re-starten
|
199 | twiStart();
|
200 | // Adresse senden
|
201 | twiWriteByte((twiAdr&0xfe)|TWI_READ,1); // mit ACKN = acknowledge = TWI-Datenanforderung
|
202 | // lesen
|
203 | uint8_t highData=twiReadByte(1); // mit ACKN = acknowledge = TWI-Datenanforderung
|
204 | uint8_t lowData=twiReadByte(0); // kein ACKN
|
205 | // Stopp
|
206 | twiStop();
|
207 | return highData;
|
208 | }
|
209 | //------------------------------------------------------------------------
|
210 | // Liest die aktuelle Temperatur
|
211 | // PE: twiAdr = TWI-Adresse der LM75
|
212 | // PA: Temperatur in 1/10 Grad
|
213 | //------------------------------------------------------------------------
|
214 | uint8_t lm75GetTempDecGrad(uint8_t twiAdr)
|
215 | {
|
216 | // TWI starten
|
217 | twiStart();
|
218 | // Adresse senden
|
219 | twiWriteByte((twiAdr&0xfe)|TWI_WRITE,0); // kein ACKN
|
220 | // Temperatur adressieren
|
221 | twiWriteByte(REG_LM75_TEMP,0); // kein ACKN
|
222 |
|
223 | //--- Lesezyklus
|
224 | // TWI re-starten
|
225 | twiStart();
|
226 | // Adresse senden
|
227 | twiWriteByte((twiAdr&0xfe)|TWI_READ,1); // mit ACKN = acknowledge = TWI-Datenanforderung
|
228 | // lesen
|
229 | uint8_t highData=twiReadByte(1); // mit ACKN = acknowledge = TWI-Datenanforderung
|
230 | uint8_t lowData=twiReadByte(0); // kein ACKN
|
231 |
|
232 | // Stopp
|
233 | twiStop();
|
234 | return (highData<<1)|(lowData>>7);
|
235 | }
|
Thread beobachten
Seitenaufteilung abschalten