Rev 195 Rev 956
1 // DART01A verze programu 1.02 1 // DART01A verze programu 1.02
2 // (c)miho 2005 2 // (c)miho 2005
3 // 3 //
4 // 1.00 Uvodni verze 4 // 1.00 Uvodni verze
5 // 1.01 Doplneno nasatvovani parametru rozjezdu P2 u standardniho algoritmu 5 // 1.01 Doplneno nasatvovani parametru rozjezdu P2 u standardniho algoritmu
6 // 1.02 Doplnena deaktivace vyvodu pro LED (LED tato verze programu nepouziva) 6 // 1.02 Doplnena deaktivace vyvodu pro LED (LED tato verze programu nepouziva)
7   7  
8 #include "DART.h" 8 #include "DART.h"
9   9  
10   10  
11 #define BEEP0 PIN_A6 // pipak, prvni vystup 11 #define BEEP0 PIN_A6 // pipak, prvni vystup
12 #define BEEP1 PIN_A7 // pipak, druhy vystup 12 #define BEEP1 PIN_A7 // pipak, druhy vystup
13 #define PWM PIN_B3 // PWM vystup pro menic 13 #define PWM PIN_B3 // PWM vystup pro menic
14 #define REFPOWER PIN_B1 // napajeni zdroje Vref 14 #define REFPOWER PIN_B1 // napajeni zdroje Vref
15 #define MOTOR PIN_B2 // zapinani motoru 15 #define MOTOR PIN_B2 // zapinani motoru
16 #define SW0 PIN_B7 // konfiguracni prepinac 0 16 #define SW0 PIN_B7 // konfiguracni prepinac 0
17 #define SW1 PIN_B6 // konfiguracni prepinac 1 17 #define SW1 PIN_B6 // konfiguracni prepinac 1
18 #define LED PIN_B4 // dioda LED v elektornice DART01B 18 #define LED PIN_B4 // dioda LED v elektornice DART01B
19   19  
20   20  
21 void InitRS232() 21 void InitRS232()
22 // Inicializace HW RS232 (pro ladici vystupy) 22 // Inicializace HW RS232 (pro ladici vystupy)
23 { 23 {
24 SPBRG=xclock/9600/16-1; // ryclost 9600Bd 24 SPBRG=xclock/9600/16-1; // ryclost 9600Bd
25 RCSTA=0b10000000; // enable USART 25 RCSTA=0b10000000; // enable USART
26 TXSTA=0b00100100; // BRGH=1, TX enable 26 TXSTA=0b00100100; // BRGH=1, TX enable
27 } 27 }
28   28  
29   29  
30 void Putc(char c) 30 void Putc(char c)
31 // Posilani znaku pres HW RS232 31 // Posilani znaku pres HW RS232
32 { 32 {
33 while(TRMT==0); // cekej na prazdny TX buffer 33 while(TRMT==0); // cekej na prazdny TX buffer
34 TXREG=c; // predej data 34 TXREG=c; // predej data
35 } 35 }
36   36  
37   37  
38 // Globalni promenna pro data posilana na SSP 38 // Globalni promenna pro data posilana na SSP
39 // Nastavuje se funkci MotorPatternSet() 39 // Nastavuje se funkci MotorPatternSet()
40 // Vyuziva se v prerusovaci rutine IntSSP() 40 // Vyuziva se v prerusovaci rutine IntSSP()
41 unsigned int8 MotorPattern; // aktualni data pro SSP jednotku 41 unsigned int8 MotorPattern; // aktualni data pro SSP jednotku
42   42  
43   43  
44 void MotorPatternSet(unsigned int Gear) 44 void MotorPatternSet(unsigned int Gear)
45 // Na zaklade rychlostniho stupne nastavi MotorPattern pro SSP 45 // Na zaklade rychlostniho stupne nastavi MotorPattern pro SSP
46 // Rychlost 0 znamena stop, rychlost 8 je maximum 46 // Rychlost 0 znamena stop, rychlost 8 je maximum
47 { 47 {
48 // Tabulka rychlost -> pattern pro SSP 48 // Tabulka rychlost -> pattern pro SSP
49 unsigned int8 const ExpTab[8] = {0x02,0x06,0x0e,0x1e,0x3e,0x7e,0xfe,0xff}; 49 unsigned int8 const ExpTab[8] = {0x02,0x06,0x0e,0x1e,0x3e,0x7e,0xfe,0xff};
50   50  
51 // Vyber patternu 51 // Vyber patternu
52 if (Gear==0) // stav 0 znamena stop 52 if (Gear==0) // stav 0 znamena stop
53 { 53 {
54 output_low(MOTOR); // klidovy stav 54 output_low(MOTOR); // klidovy stav
55 SSPSTAT = 0; 55 SSPSTAT = 0;
56 SSPCON1 = 0; // SPI stop 56 SSPCON1 = 0; // SPI stop
57 disable_interrupts(INT_SSP); // neni preruseni od SSP 57 disable_interrupts(INT_SSP); // neni preruseni od SSP
58 } 58 }
59 else // rizeny vykon 59 else // rizeny vykon
60 { 60 {
61 if (Gear>7) // stav 8 a vice znamena plny vykon 61 if (Gear>7) // stav 8 a vice znamena plny vykon
62 { 62 {
63 Gear=8; // plny plyn 63 Gear=8; // plny plyn
64 } 64 }
65   65  
66 MotorPattern=ExpTab[--Gear]; // prevod z hodnoty plynu na data pro SSP 66 MotorPattern=ExpTab[--Gear]; // prevod z hodnoty plynu na data pro SSP
67 output_low(MOTOR); // klidovy stav 67 output_low(MOTOR); // klidovy stav
68 SSPSTAT = 0; 68 SSPSTAT = 0;
69 SSPCON1 = 0x22; // SPI OSC/64 69 SSPCON1 = 0x22; // SPI OSC/64
70   70  
71 SSPBUF=MotorPattern; // prvni data pro vyslani 71 SSPBUF=MotorPattern; // prvni data pro vyslani
72 enable_interrupts(INT_SSP); // az budou vyslana prijde interrupt od SSP 72 enable_interrupts(INT_SSP); // az budou vyslana prijde interrupt od SSP
73 } 73 }
74 } 74 }
75   75  
76   76  
77 // Obsluha preruseni od SSP jednotky, posila data z promenne MotorRun do SSP. 77 // Obsluha preruseni od SSP jednotky, posila data z promenne MotorRun do SSP.
78 #INT_SSP 78 #INT_SSP
79 void IntSSP() 79 void IntSSP()
80 { 80 {
81 SSPBUF=MotorPattern; // znova hdnota PWM patternu na SSP 81 SSPBUF=MotorPattern; // znova hdnota PWM patternu na SSP
82 } 82 }
83   83  
84   84  
85 void MotorSet(unsigned int Gear) 85 void MotorSet(unsigned int Gear)
86 // Nastavi vykon motoru dle hodnoty Gear a zahaji posilani PWM dat pres SSP pod prerusenim 86 // Nastavi vykon motoru dle hodnoty Gear a zahaji posilani PWM dat pres SSP pod prerusenim
87 // od SSP jednotky 87 // od SSP jednotky
88 // 0 stop 88 // 0 stop
89 // 1-7 pocet 1/8 vykonu 89 // 1-7 pocet 1/8 vykonu
90 // >7 plny vykon 90 // >7 plny vykon
91 { 91 {
92 // Nastav PWM pattern 92 // Nastav PWM pattern
93 MotorPatternSet(Gear); // nastav PWM pattern pro SSP 93 MotorPatternSet(Gear); // nastav PWM pattern pro SSP
94   94  
95 // Povol preruseni 95 // Povol preruseni
96 enable_interrupts(GLOBAL); // povol preruseni 96 enable_interrupts(GLOBAL); // povol preruseni
97 } 97 }
98   98  
99   99  
100 void InitT0() 100 void InitT0()
101 // Inicializace casovace T0 (cca 1000x za sekundu) 101 // Inicializace casovace T0 (cca 1000x za sekundu)
102 { 102 {
103 setup_timer_0(RTCC_INTERNAL|RTCC_DIV_4); // T0 z internich hodin 1/4 103 setup_timer_0(RTCC_INTERNAL|RTCC_DIV_4); // T0 z internich hodin 1/4
104 enable_interrupts(INT_RTCC); // generuj preruseni od T0 104 enable_interrupts(INT_RTCC); // generuj preruseni od T0
105 enable_interrupts(GLOBAL); // povol preruseni 105 enable_interrupts(GLOBAL); // povol preruseni
106 } 106 }
107   107  
108   108  
109 // Globalni promenna pro mereni casu 109 // Globalni promenna pro mereni casu
110 // Nastavuje se procedurou TimeSet() 110 // Nastavuje se procedurou TimeSet()
111 // Testuje se funkci TimeIf() 111 // Testuje se funkci TimeIf()
112 // Modifikuje se pri preruseni od casovace IntTo() 112 // Modifikuje se pri preruseni od casovace IntTo()
113 unsigned int16 TimeTime; 113 unsigned int16 TimeTime;
114   114  
115   115  
116 void TimerSet(unsigned int16 Time) 116 void TimerSet(unsigned int16 Time)
117 // Nastavi casovac na zadany pocet ms 117 // Nastavi casovac na zadany pocet ms
118 // Test uplynuti casu se dela pomoci TimerIf() 118 // Test uplynuti casu se dela pomoci TimerIf()
119 { 119 {
120 // Nastav hodnotu 120 // Nastav hodnotu
121 disable_interrupts(INT_RTCC); // nesmi prijit preruseni 121 disable_interrupts(INT_RTCC); // nesmi prijit preruseni
122 TimeTime=Time; // pri nastavovani hodnoty 122 TimeTime=Time; // pri nastavovani hodnoty
123 enable_interrupts(INT_RTCC); // promenne (o delce vice nez 8 bitu) 123 enable_interrupts(INT_RTCC); // promenne (o delce vice nez 8 bitu)
124 } 124 }
125   125  
126   126  
127 int1 TimerIf() 127 int1 TimerIf()
128 // Vraci TRUE pokud casovac jiz dobehl 128 // Vraci TRUE pokud casovac jiz dobehl
129 { 129 {
130 int1 Flag; // pomocna promenna 130 int1 Flag; // pomocna promenna
131   131  
132 // Otestuj casovac 132 // Otestuj casovac
133 disable_interrupts(INT_RTCC); // nesmi prijit preruseni 133 disable_interrupts(INT_RTCC); // nesmi prijit preruseni
134 Flag=(TimeTime==0); // behem testu promenne 134 Flag=(TimeTime==0); // behem testu promenne
135 enable_interrupts(INT_RTCC); // ted uz muze 135 enable_interrupts(INT_RTCC); // ted uz muze
136   136  
137 // Navratova hodnota 137 // Navratova hodnota
138 return Flag; // TRUE znamena dobehl casovac 138 return Flag; // TRUE znamena dobehl casovac
139 } 139 }
140   140  
141   141  
142 // Globalni promenne pro akceleraci 142 // Globalni promenne pro akceleraci
143 // Nastavuje se metodou MotorStart() 143 // Nastavuje se metodou MotorStart()
144 // Pouziva se v obsluze preruseni IntT0() 144 // Pouziva se v obsluze preruseni IntT0()
145 unsigned int8 MotorTime; // aktualni casovac pro rozjezd 145 unsigned int8 MotorTime; // aktualni casovac pro rozjezd
146 unsigned int8 MotorDelay; // spozdeni mezi razenim rychlosti 146 unsigned int8 MotorDelay; // spozdeni mezi razenim rychlosti
147 unsigned int8 MotorGear; // rychlostni stupen 147 unsigned int8 MotorGear; // rychlostni stupen
148   148  
149   149  
150 void MotorStart(unsigned int8 Delay) 150 void MotorStart(unsigned int8 Delay)
151 // Provede rizeny rozjezd motoru 151 // Provede rizeny rozjezd motoru
152 // Parametrem je prodleva mezi razenim rychlosti v ms 152 // Parametrem je prodleva mezi razenim rychlosti v ms
153 { 153 {
154 disable_interrupts(INT_RTCC); 154 disable_interrupts(INT_RTCC);
155 MotorGear=1; 155 MotorGear=1;
156 MotorDelay=Delay; 156 MotorDelay=Delay;
157 MotorTime=MotorDelay; 157 MotorTime=MotorDelay;
158 enable_interrupts(INT_RTCC); 158 enable_interrupts(INT_RTCC);
159   159  
160 MotorPatternSet(1); 160 MotorPatternSet(1);
161 } 161 }
162   162  
163   163  
164 #INT_TIMER0 164 #INT_TIMER0
165 void IntT0() 165 void IntT0()
166 // Preruseni od casovace cca 1000x za sekundu 166 // Preruseni od casovace cca 1000x za sekundu
167 { 167 {
168 // Odpocitavani casovace 168 // Odpocitavani casovace
169 if (TimeTime) TimeTime--; 169 if (TimeTime) TimeTime--;
170   170  
171 // Obsluha akcelerace 171 // Obsluha akcelerace
172 if (MotorTime) MotorTime--; // dekrementuj casovac rozjezdu 172 if (MotorTime) MotorTime--; // dekrementuj casovac rozjezdu
173 if ((MotorGear>0) && (MotorGear<8) && (!MotorTime)) // dalsi rychlostni stupen 173 if ((MotorGear>0) && (MotorGear<8) && (!MotorTime)) // dalsi rychlostni stupen
174 { 174 {
175 MotorTime=MotorDelay; // znovu nastav casovac 175 MotorTime=MotorDelay; // znovu nastav casovac
176 MotorGear++; // dalsi rychlost 176 MotorGear++; // dalsi rychlost
177 MotorPatternSet(MotorGear); // nastav rychlost 177 MotorPatternSet(MotorGear); // nastav rychlost
178 } 178 }
179 } 179 }
180   180  
181   181  
182 // Cteni dat z AD prevodniku, zadava se cislo kanalu 182 // Cteni dat z AD prevodniku, zadava se cislo kanalu
183 int8 ReadAD(int8 Ch) 183 int8 ReadAD(int8 Ch)
184 { 184 {
185 // Pokud merim Vref zapnu si jeho napajeni 185 // Pokud merim Vref zapnu si jeho napajeni
186 if (Ch==4) output_high(REFPOWER); 186 if (Ch==4) output_high(REFPOWER);
187   187  
188 // Inicializace a cislo kanalu 188 // Inicializace a cislo kanalu
189 ADCON1=0x30; // Vref+-, bez deleni hodin, Left Justify 189 ADCON1=0x30; // Vref+-, bez deleni hodin, Left Justify
190 ADCON0=0x41+(Ch<<3); // on, Tosc/8, cislo kanalu 190 ADCON0=0x41+(Ch<<3); // on, Tosc/8, cislo kanalu
191   191  
192 // Mereni 192 // Mereni
193 delay_us(50); // doba na prepnuti kanalu 193 delay_us(50); // doba na prepnuti kanalu
194 ADCON0 |= 4; // start prevodu 194 ADCON0 |= 4; // start prevodu
195 delay_us(50); // doba na prevod 195 delay_us(50); // doba na prevod
196   196  
197 // Vypnu napajeni Vref (vzdycky) 197 // Vypnu napajeni Vref (vzdycky)
198 output_low(REFPOWER); 198 output_low(REFPOWER);
199   199  
200 // Navrat hodnoty 200 // Navrat hodnoty
201 return ADRESH; 201 return ADRESH;
202 } 202 }
203   203  
204   204  
205 void main() 205 void main()
206 { 206 {
207 unsigned int8 Debug; // Promenna pro rezim cinnosti (stav prepinacu) 207 unsigned int8 Debug; // Promenna pro rezim cinnosti (stav prepinacu)
208 unsigned int8 i; 208 unsigned int8 i;
209   209  
210 // Hodiny 210 // Hodiny
211 OSCCON = 0x62; // 4 MHz interni RC oscilator 211 OSCCON = 0x62; // 4 MHz interni RC oscilator
212   212  
213 // Digitalni vystupy 213 // Digitalni vystupy
214 output_low(PWM); // PWM vystup 214 output_low(PWM); // PWM vystup
215 output_low(MOTOR); // Proud do motoru 215 output_low(MOTOR); // Proud do motoru
216 output_low(REFPOWER); // Napajeni Vref 216 output_low(REFPOWER); // Napajeni Vref
217 output_low(LED); // LED dioda nesviti 217 output_low(LED); // LED dioda nesviti
218 port_b_pullups(TRUE); // Zbyvajici vyvody portu B 218 port_b_pullups(TRUE); // Zbyvajici vyvody portu B
219   219  
220 // Watch Dog 220 // Watch Dog
221 PSA=0; // preddelic prirazen casovaci 221 PSA=0; // preddelic prirazen casovaci
222 WDTCON=0x0E; // Watch Dog cca 130ms 222 WDTCON=0x0E; // Watch Dog cca 130ms
223   223  
224 // Analogove vstupy 224 // Analogove vstupy
225 ANSEL = 0x1F; // AN0 az AN4 225 ANSEL = 0x1F; // AN0 az AN4
226   226  
227 // nastaveni RS232 227 // nastaveni RS232
228 InitRS232(); // inicializace HW RS232 (nutno pockat cca 10ms) 228 InitRS232(); // inicializace HW RS232 (nutno pockat cca 10ms)
229   229  
230 // Pipnuti (a cekani) 230 // Pipnuti (a cekani)
231 for (i=1;i<30;i++) // pocet 1/2 period 231 for (i=1;i<30;i++) // pocet 1/2 period
232 { 232 {
233 int1 beep; // stavova promenna pro pipak 233 int1 beep; // stavova promenna pro pipak
234   234  
235 output_bit(BEEP0,beep); 235 output_bit(BEEP0,beep);
236 beep=~beep; 236 beep=~beep;
237 output_bit(BEEP1,beep); 237 output_bit(BEEP1,beep);
238 delay_us(1000); 238 delay_us(1000);
239 } 239 }
240   240  
241 // Rozhodnuti o rezimu cinnosti (cteni stavu prepinacu) 241 // Rozhodnuti o rezimu cinnosti (cteni stavu prepinacu)
242 Debug=0; 242 Debug=0;
243 if (~input(SW0)) Debug|=1; // precti bit 0 243 if (~input(SW0)) Debug|=1; // precti bit 0
244 if (~input(SW1)) Debug|=2; // precti bit 1 244 if (~input(SW1)) Debug|=2; // precti bit 1
245 output_low(SW0); // nastav L aby se snizila spotreba 245 output_low(SW0); // nastav L aby se snizila spotreba
246 output_low(SW1); // na obou vstupech 246 output_low(SW1); // na obou vstupech
247   247  
248 // Zobrazeni rezimu (na ladici seriovy vystup) 248 // Zobrazeni rezimu (na ladici seriovy vystup)
249 printf(Putc,"\fMode:%d",Debug); 249 printf(Putc,"\fMode:%d",Debug);
250   250  
251 // Inicializace PWM 251 // Inicializace PWM
252 PR2 = 0x1F; // perioda PWM casovace 252 PR2 = 0x1F; // perioda PWM casovace
253 T2CON = 0x04; // povoleni casovace T2 bez preddelicu a postdelicu 253 T2CON = 0x04; // povoleni casovace T2 bez preddelicu a postdelicu
254 CCP1CON = 0x0C; // PWM mode, lsb bity nulove 254 CCP1CON = 0x0C; // PWM mode, lsb bity nulove
255 CCPR1L = 0; // na zacatku nulova data 255 CCPR1L = 0; // na zacatku nulova data
256 output_low(PWM); // PWM vystup 256 output_low(PWM); // PWM vystup
257   257  
258 // Inicializace casovace 258 // Inicializace casovace
259 InitT0(); // nastav casovac na cca 1ms 259 InitT0(); // nastav casovac na cca 1ms
260   260  
261 // ALG=1 Test menice PWM a rozjezdoveho PWM 261 // ALG=1 Test menice PWM a rozjezdoveho PWM
262 // ======================================== 262 // ========================================
263 // P1 nastavuje primo stridu hlavniho PWM menice 263 // P1 nastavuje primo stridu hlavniho PWM menice
264 // P2 nastavuje rychlostni stupen spinace motoru (rychlostni stupne 0-8) 264 // P2 nastavuje rychlostni stupen spinace motoru (rychlostni stupne 0-8)
265 // Trvale nacita P1 a P2 a nastavuje podle nich akcni hodnoty menicu 265 // Trvale nacita P1 a P2 a nastavuje podle nich akcni hodnoty menicu
266 if (Debug==1) 266 if (Debug==1)
267 { 267 {
268 unsigned int8 Data1; // poteniometr P1 = PWM 268 unsigned int8 Data1; // poteniometr P1 = PWM
269 unsigned int8 Data2; // poteniometr P2 = Rozjezd 269 unsigned int8 Data2; // poteniometr P2 = Rozjezd
270   270  
271 while (1) 271 while (1)
272 { 272 {
273 // watch dog 273 // watch dog
274 restart_wdt(); 274 restart_wdt();
275   275  
276 // mereni vstupu 276 // mereni vstupu
277 Data1=ReadAD(0); // nacti parametr pro PWM 277 Data1=ReadAD(0); // nacti parametr pro PWM
278 Data1>>=2; // redukuj rozsah na 0 az 63 278 Data1>>=2; // redukuj rozsah na 0 az 63
279 Data2=ReadAD(1); // nacti parametr pro rozjezd 279 Data2=ReadAD(1); // nacti parametr pro rozjezd
280 Data2>>=4; // redukuj rozsah na 0 az 15 280 Data2>>=4; // redukuj rozsah na 0 az 15
281   281  
282 // zobrazeni 282 // zobrazeni
283 printf(Putc,"\nPWM:%03u RUN:%03u",Data1,Data2); 283 printf(Putc,"\nPWM:%03u RUN:%03u",Data1,Data2);
284 delay_ms(20); 284 delay_ms(20);
285   285  
286 // nastaveni parametru PWM 286 // nastaveni parametru PWM
287 CCPR1L = Data1; 287 CCPR1L = Data1;
288   288  
289 // nastaveni parametru RUN 289 // nastaveni parametru RUN
290 MotorSet(Data2); 290 MotorSet(Data2);
291 } 291 }
292 } 292 }
293   293  
294 // ALG=2 Testovani rozjezdu 294 // ALG=2 Testovani rozjezdu
295 // ======================== 295 // ========================
296 // P2 nastavuje cas mezi stupni razeni pro rozjezd v ms 296 // P2 nastavuje cas mezi stupni razeni pro rozjezd v ms
297 // Po resetu 2 sekundy pocka, 2 sekundy jede a nakonec zastavi motor 297 // Po resetu 2 sekundy pocka, 2 sekundy jede a nakonec zastavi motor
298 if (Debug==2) 298 if (Debug==2)
299 { 299 {
300 int8 Data; 300 int8 Data;
301 int8 Start; 301 int8 Start;
302   302  
303 Start=0; // uvodni stav 303 Start=0; // uvodni stav
304 while(1) 304 while(1)
305 { 305 {
306 // Nacti a zobraz parametr 306 // Nacti a zobraz parametr
307 Data=ReadAD(1); // potenciometr P2 = rozjezd 307 Data=ReadAD(1); // potenciometr P2 = rozjezd
308 printf(Putc,"\nRUN:%3ums ",Data); // zobraz 308 printf(Putc,"\nRUN:%3ums ",Data); // zobraz
309 delay_ms(10); // prodleva pro terminal 309 delay_ms(10); // prodleva pro terminal
310   310  
311 // Uvodni pauza 311 // Uvodni pauza
312 if (Start==0) // spousti se 1x na zacatku 312 if (Start==0) // spousti se 1x na zacatku
313 { 313 {
314 Start++; // dalsi stav je cekani 314 Start++; // dalsi stav je cekani
315 TimerSet(2000); // na dokonceni uvodni prodlevy 315 TimerSet(2000); // na dokonceni uvodni prodlevy
316 } 316 }
317   317  
318 // Rozjezd 318 // Rozjezd
319 if ((Start==1) && TimerIf()) 319 if ((Start==1) && TimerIf())
320 { 320 {
321 Start++; 321 Start++;
322 printf(Putc,"R"); 322 printf(Putc,"R");
323 MotorStart(Data); // rozjezd s nastavenim prodlevy 323 MotorStart(Data); // rozjezd s nastavenim prodlevy
324   324  
325 TimerSet(2000); // nastav celkovy cas jizdy 325 TimerSet(2000); // nastav celkovy cas jizdy
326 } 326 }
327   327  
328 // Zastaveni 328 // Zastaveni
329 if ((Start==2) && TimerIf()) 329 if ((Start==2) && TimerIf())
330 { 330 {
331 Start++; 331 Start++;
332 printf(Putc,"S"); 332 printf(Putc,"S");
333 MotorSet(0); // pokud dobehl casovac zastav motor 333 MotorSet(0); // pokud dobehl casovac zastav motor
334 } 334 }
335   335  
336 // watch dog 336 // watch dog
337 restart_wdt(); 337 restart_wdt();
338 } 338 }
339 } 339 }
340   340  
341 // ALG=3 Test nabijeciho algoritmu 341 // ALG=3 Test nabijeciho algoritmu
342 // =============================== 342 // ===============================
343 // P1 nastavuje pozadovane napeti na clancich (meri se Vref vuci napajeni) 343 // P1 nastavuje pozadovane napeti na clancich (meri se Vref vuci napajeni)
344 // Nacitani P1 probiha stale dokola, pro rizeni je pouzit stejny 344 // Nacitani P1 probiha stale dokola, pro rizeni je pouzit stejny
345 // algoritmus jako pro standardni jizdu 345 // algoritmus jako pro standardni jizdu
346 if (Debug==3) 346 if (Debug==3)
347 { 347 {
348 unsigned int8 PwmOut; // akcni hodnota pro PWM 348 unsigned int8 PwmOut; // akcni hodnota pro PWM
349 unsigned int8 Req; // pozadovana hodnota z P1 349 unsigned int8 Req; // pozadovana hodnota z P1
350 unsigned int8 Vref; // merena hodnota vref 350 unsigned int8 Vref; // merena hodnota vref
351   351  
352 // Inicializace stavove promenne 352 // Inicializace stavove promenne
353 PwmOut=0; 353 PwmOut=0;
354   354  
355 // Hlavni smycka 355 // Hlavni smycka
356 while (1) 356 while (1)
357 { 357 {
358 // watch dog 358 // watch dog
359 restart_wdt(); 359 restart_wdt();
360   360  
361 // pozadovana hodnota (potenciometr P1) 361 // pozadovana hodnota (potenciometr P1)
362 Req=ReadAD(0); 362 Req=ReadAD(0);
363 Req=50+(ReadAD(0)>>1); // 50 az 177 363 Req=50+(ReadAD(0)>>1); // 50 az 177
364   364  
365 // napeti na napajeni (vref) 365 // napeti na napajeni (vref)
366 Vref=ReadAD(4); 366 Vref=ReadAD(4);
367   367  
368 // ricici algoritmus 368 // ricici algoritmus
369 if ((Vref<Req) &&(PwmOut<30)) PwmOut++; 369 if ((Vref<Req) &&(PwmOut<30)) PwmOut++;
370 if ((Vref>=Req)&&(PwmOut> 0)) PwmOut--; 370 if ((Vref>=Req)&&(PwmOut> 0)) PwmOut--;
371 Vref+=10; 371 Vref+=10;
372 if ((Vref<(Req))&&(PwmOut<30)) PwmOut++; // urychleni nabehu 372 if ((Vref<(Req))&&(PwmOut<30)) PwmOut++; // urychleni nabehu
373   373  
374 // nastaveni parametru PWM 374 // nastaveni parametru PWM
375 if (PwmOut>24) PwmOut=24; // saturace 375 if (PwmOut>24) PwmOut=24; // saturace
376 CCPR1L = PwmOut; // pouziti vystupu 376 CCPR1L = PwmOut; // pouziti vystupu
377   377  
378 // zobrazeni 378 // zobrazeni
379 printf(Putc,"\nALG:%03u %03u %03u",Req,Vref,PwmOut); 379 printf(Putc,"\nALG:%03u %03u %03u",Req,Vref,PwmOut);
380 delay_ms(10); 380 delay_ms(10);
381 } 381 }
382 } 382 }
383   383  
384 // ALG=0 Standardni jizda 384 // ALG=0 Standardni jizda
385 // ====================== 385 // ======================
386 // P1 nastavuje pozadovane napeti na clancich 386 // P1 nastavuje pozadovane napeti na clancich
387 // P2 nastavuje prodlevu razeni pri rozjezdu, nacita se jen 1x na zacatku 387 // P2 nastavuje prodlevu razeni pri rozjezdu, nacita se jen 1x na zacatku
388 // Po resetu cca 14.5 sekundy akumuluje do kondenzatoru a pak provede 388 // Po resetu cca 14.5 sekundy akumuluje do kondenzatoru a pak provede
389 // rozjezd motoru. Po celou dobu probiha rizeni zateze slunecnich clanku. 389 // rozjezd motoru. Po celou dobu probiha rizeni zateze slunecnich clanku.
390 // Parametry P1 a P2 jsou chapany stejne jako v algoritmech 2 a 3. 390 // Parametry P1 a P2 jsou chapany stejne jako v algoritmech 2 a 3.
391 if (Debug==0) 391 if (Debug==0)
392 { 392 {
393 unsigned int8 PwmOut; // akcni hodnota pro PWM 393 unsigned int8 PwmOut; // akcni hodnota pro PWM
394 unsigned int8 Req; // pozadovana hodnota z P1 394 unsigned int8 Req; // pozadovana hodnota z P1
395 unsigned int8 Vref; // merena hodnota vref 395 unsigned int8 Vref; // merena hodnota vref
396 int8 Delay; // pozadovana honota prodlevy razeni z P2 396 int8 Delay; // pozadovana honota prodlevy razeni z P2
397 int1 Run; 397 int1 Run;
398   398  
399 // Nacti parametr rozjezdu 399 // Nacti parametr rozjezdu
400 Delay=ReadAD(1); // potenciometr P2 = rozjezd 400 Delay=ReadAD(1); // potenciometr P2 = rozjezd
401 printf(Putc," RUN:%3ums ",Delay); // zobraz 401 printf(Putc," RUN:%3ums ",Delay); // zobraz
402 delay_ms(10); // prodleva pro terminal 402 delay_ms(10); // prodleva pro terminal
403   403  
404 // Inicializace stavove promenne 404 // Inicializace stavove promenne
405 PwmOut=0; 405 PwmOut=0;
406 TimerSet(14000); // casovani startu 406 TimerSet(14000); // casovani startu
407 Run=1; 407 Run=1;
408   408  
409 // Hlavni smycka 409 // Hlavni smycka
410 while (1) 410 while (1)
411 { 411 {
412 // watch dog 412 // watch dog
413 restart_wdt(); 413 restart_wdt();
414   414  
415 // pozadovana hodnota (potenciometr P1) 415 // pozadovana hodnota (potenciometr P1)
416 Req=ReadAD(0); 416 Req=ReadAD(0);
417 Req=50+(ReadAD(0)>>1); // 50 az 177 417 Req=50+(ReadAD(0)>>1); // 50 az 177
418   418  
419 // napeti na napajeni (vref) 419 // napeti na napajeni (vref)
420 Vref=ReadAD(4); 420 Vref=ReadAD(4);
421   421  
422 // ricici algoritmus 422 // ricici algoritmus
423 if ((Vref<Req) &&(PwmOut<30)) PwmOut++; 423 if ((Vref<Req) &&(PwmOut<30)) PwmOut++;
424 if ((Vref>=Req)&&(PwmOut> 0)) PwmOut--; 424 if ((Vref>=Req)&&(PwmOut> 0)) PwmOut--;
425 Vref+=10; 425 Vref+=10;
426 if ((Vref<(Req))&&(PwmOut<30)) PwmOut++; // urychleni nabehu 426 if ((Vref<(Req))&&(PwmOut<30)) PwmOut++; // urychleni nabehu
427   427  
428 // nastaveni parametru PWM 428 // nastaveni parametru PWM
429 if (PwmOut>24) PwmOut=24; // saturace 429 if (PwmOut>24) PwmOut=24; // saturace
430 CCPR1L = PwmOut; // pouziti vystupu 430 CCPR1L = PwmOut; // pouziti vystupu
431   431  
432 // zobrazeni 432 // zobrazeni
433 printf(Putc,"\nALG:%03u %03u %03u",Req,Vref,PwmOut); 433 printf(Putc,"\nALG:%03u %03u %03u",Req,Vref,PwmOut);
434 delay_ms(10); 434 delay_ms(10);
435   435  
436 // rozjezd 436 // rozjezd
437 if (TimerIf()&&Run) 437 if (TimerIf()&&Run)
438 { 438 {
439 Run=0; 439 Run=0;
440 MotorStart(Delay); // prodleva razeni z P2 440 MotorStart(Delay); // prodleva razeni z P2
441 } 441 }
442 } 442 }
443 } 443 }
444 } 444 }