WebSVN - Projects - Diff - Rev 341 and 342 - /MikroBlink/Blitzdings/main.c


/*
 * Blitzdings main.c
 * (c) pangu
 */
 
/******************************************************************/
/* WICHTIG: Fusebits in Ponyprog für 8MHz setzen:
 
                Häkchen in Ponyprog:
                CKSEL3 gesetzt
                CKSEL2 nicht gesetzt
                CKSEL1 gesetzt
                CKSEL0 gesetzt
 
 */
/******************************************************************/
 
#include "main.h"
#include "timer.h"
 
#include "lprg.h"
 
/* Strings zum definieren von Dauer-Ein Dauer-Aus */
const char l_on[]="A";
const char l_off[]="a";
 
// Wait flags:
// .  10 ms
// :  20 ms
// ;  50 ms
// I 100 ms
// N 200 ms
// M 300 ms
// V 500 ms
// S 1s
// LED:
// A-an a-aus
 
// Rot+Grün blitzen dreimal kurz, zeitlich leicht versetzt, alle 1,5s
// 2 weisse und 2 blaue LEDs sind an und gehen alle 3s reihum kurz aus
char *led_posflash1[] = {    
"A:aIA:aIA:aSV",                // LED #1    rot
".",                                    // LED #2    
"NNaIASSNNN",                   // LED #3    blau
".",                                    // LED #4
"NaIASSNNNN",                   // LED #5    weiss
"NA:aIA:aIA:aMS",               // LED #6    grün
".",                                    // LED #7
"aIASSNNNNN",                   // LED #8    weiss
".",                                    // LED #9 
"NNNaIASSNN"                    // LED #10   blau
};
 
// dasselbe, nur sind w/b dauer-an
char *led_posflash[] = {    
"A",            // LED #1    rot
"A",                                    // LED #2    
"A",                    // LED #3    blau
"A",                                    // LED #4
"A:aIA:aIA:aSV",                        // LED #5    weiss
"NA:aIA:aIA:aMS",               // LED #6    grün
"A",                                    // LED #7
"A",                    // LED #8    weiss
"A",                                    // LED #9 
"A"                     // LED #10   blau
};
 
 
char *led_aus[] = {
l_off,          // LED #1    rot
l_off,          // LED #2    blau
l_off,          // LED #3    blau
l_off,          // LED #4
l_off,          // LED #5    weiss
l_off,          // LED #6    grün
l_off,          // LED #7
l_off,          // LED #8    weiss
l_off,          // LED #9 
l_off           // LED #10
};
 
char *led_an[] = {
l_on,           // LED #1    rot
l_on,           // LED #2    blau
l_on,           // LED #3    blau
l_on,           // LED #4
l_on,           // LED #5    weiss
l_on,           // LED #6    grün
l_on,           // LED #7
l_on,           // LED #8    weiss
l_on,           // LED #9 
l_on            // LED #10
};
 
// alle LEDs toggeln synchron, 300ms Leucht/Aus-Dauer
char *led_flash1[] = {
"aMAM",         // LED #1    rot
"aMAM",         // LED #2    blau
"aMAM",         // LED #3    blau
"aMAM",         // LED #4
"aMAM",         // LED #5    weiss
"aMAM",         // LED #6    grün
"aMAM",         // LED #7
"aMAM",         // LED #8    weiss
"aMAM",         // LED #9 
"aMAM"          // LED #10
};
 
// low Volatage Warning: alle LEDs toggeln synchron, 100ms Leucht/Aus-Dauer
char *led_lowVolt[] = {
"aIAI",         // LED #1    rot
"aIAI",         // LED #2    blau
"aIAI",         // LED #3    blau
"aIAI",         // LED #4
"aIAI",         // LED #5    weiss
"aIAI",         // LED #6    grün
"aIAI",         // LED #7
"aIAI",         // LED #8    weiss
"aIAI",         // LED #9 
"aIAI"          // LED #10
};
 
// alle LEDs toggeln mit verschiednen Zykluszeiten
char *led_flash2[] = {
"a.A.",         // LED #1    rot
"a:A:",         // LED #2    blau
"a;A;",         // LED #3    blau
"aIAI",         // LED #4
"aNAN",         // LED #5    weiss
"aMAM",         // LED #6    grün
"aMIAMI",               // LED #7
"aVAV",         // LED #8    weiss
"aVIAVI",               // LED #9 
"aSAS"          // LED #10
};
 
 
// Hier die zu verwendenden LichtProgramme einfach eintragen.
 
int current = 0;
 
void *modes[]= { led_posflash, led_posflash1, led_an, led_flash1,led_aus, led_flash2 };
 
void nextMode(void) {
   
        current = ++current % (sizeof(modes)/sizeof(void *));
        lprg_init(modes[current]);     
       
}
 
ISR(INT1_vect)      
{
 
  nextMode();
 
}
 
 
int main(void) {
 
        int tim1s, tim3s, tim10s, analog_state=0;
        int Vcurr;
       
        SFIOR  =  0x00;  // Analog Comperator aus
        ADCSRA =  0xD3;  // Converter ein, single       
       
        // Ports einstellen
        // Pin B |7|6|5|4|3|2|1|0
    // Binär:|0|0|0|0|0|1|0|1 (b) => #05 (h)
        // Pin B0 und B2 als Ausgänge festlegen   
    DDRB = 0x05;
 
        // Pin C |7|6|5|4|3|2|1|0
    // Binär:|0|0|1|1|1|1|1|0 (b) => #3E (h)
        // Pin C1 bis C5 als Ausgänge festlegen   
    DDRC = 0x3E;
       
        // Pin D |7|6|5|4|3|2|1|0
    // Binär:|1|1|1|1|0|0|0|0 (b) => #F0 (h)
        DDRD = 0xF0;
        //Pullup für PD3 aktivieren
        PORTD |= (1 << PD3);
       
       
        //interrupt konfigurueren
        GIMSK = 1<<INT1;
        MCUCR = 1<<ISC10;
 
        ALLES_OFF;
       
        STATUS_ON;
 
        Timer_Init();
 
        lprg_init(modes[current]);
        tim10s = SetDelay(10000);
        tim3s  = SetDelay(3000);
        tim1s  = SetDelay(1000);
       
       
        sei();  //interrupts einschalten
 
        while (1) {
 
                if(flag10ms) {    // every 10ms
                        flag10ms = 0;
                        lprg_step();   // next step in light prog   
 
                        if(!analog_state) {    // Sampling der SPannung starten
                                  ADMUX = 0 | 0xC0;  // Kanal 0, interne Referenz
                                  ADCSRA |= 0x10;  // Ready löschen
                                  ADCSRA |= 0x40;  // Start
                                  analog_state++;  // erst wieder sampeln, wenn der Wert ausgelesen wurde
                        }
                         
                }
 
                // 1s-Task: Status-LED toggeln, Spannung checken
        if(CheckDelay(tim1s)) {  
                        if (ADCSRA & 0x10) { // Spannungs-Messung beendet?
                          ADCSRA = 0xD3;  
                          Vcurr = ADCW;      // Wert merken
                          analog_state = 0;
                        }
                        if(Vcurr < 180) {
                                lprg_init(led_lowVolt);
                        }
                        if(Vcurr>=180) {
                                lprg_init(modes[current]);     
                        }
                        STATUS_TOGGLE;
                        tim1s = SetDelay(1000);  
                }
 
                // 3s-Task: Unterspannungswarnung ggf. zurücknehmen
        if(CheckDelay(tim3s)) {  
 
                        tim3s = SetDelay(3000);  
                }
 
                // 10s-Task: DEMO: programm wechseln
        if(CheckDelay(tim10s)) {  
                        nextMode();  
                        tim10s = SetDelay(10000);  
                }
 
 
 
        }
 
}
 
 
 
 
 
 

Rev 341	Rev 342
1	/*	1	/*
2	* Blitzdings main.c	2	* Blitzdings main.c
3	* (c) pangu	3	* (c) pangu
4	*/	4	*/
5		5
6	/******************************************************************/	6	/******************************************************************/
7	/* WICHTIG: Fusebits in Ponyprog für 8MHz setzen:	7	/* WICHTIG: Fusebits in Ponyprog für 8MHz setzen:
8		8
9	Häkchen in Ponyprog:	9	Häkchen in Ponyprog:
10	CKSEL3 gesetzt	10	CKSEL3 gesetzt
11	CKSEL2 nicht gesetzt	11	CKSEL2 nicht gesetzt
12	CKSEL1 gesetzt	12	CKSEL1 gesetzt
13	CKSEL0 gesetzt	13	CKSEL0 gesetzt
14		14
15	*/	15	*/
16	/******************************************************************/	16	/******************************************************************/
17		17
18	#include "main.h"	18	#include "main.h"
19	#include "timer.h"	19	#include "timer.h"
20	#include "analog.h"	-
21	#include "lprg.h"	20	#include "lprg.h"
22		21
23	/* Strings zum definieren von Dauer-Ein Dauer-Aus */	22	/* Strings zum definieren von Dauer-Ein Dauer-Aus */
24	const char l_on[]="A";	23	const char l_on[]="A";
25	const char l_off[]="a";	24	const char l_off[]="a";
26		25
27	// Wait flags:	26	// Wait flags:
28	// . 10 ms	27	// . 10 ms
29	// : 20 ms	28	// : 20 ms
30	// ; 50 ms	29	// ; 50 ms
31	// I 100 ms	30	// I 100 ms
32	// N 200 ms	31	// N 200 ms
33	// M 300 ms	32	// M 300 ms
34	// V 500 ms	33	// V 500 ms
35	// S 1s	34	// S 1s
36	// LED:	35	// LED:
37	// A-an a-aus	36	// A-an a-aus
38		37
39	// Rot+Grün blitzen dreimal kurz, zeitlich leicht versetzt, alle 1,5s	38	// Rot+Grün blitzen dreimal kurz, zeitlich leicht versetzt, alle 1,5s
40	// 2 weisse und 2 blaue LEDs sind an und gehen alle 3s reihum kurz aus	39	// 2 weisse und 2 blaue LEDs sind an und gehen alle 3s reihum kurz aus
41	char *led_posflash1[] = {	40	char *led_posflash1[] = {
42	"A:aIA:aIA:aSV", // LED #1 rot	41	"A:aIA:aIA:aSV", // LED #1 rot
43	".", // LED #2	42	".", // LED #2
44	"NNaIASSNNN", // LED #3 blau	43	"NNaIASSNNN", // LED #3 blau
45	".", // LED #4	44	".", // LED #4
46	"NaIASSNNNN", // LED #5 weiss	45	"NaIASSNNNN", // LED #5 weiss
47	"NA:aIA:aIA:aMS", // LED #6 grün	46	"NA:aIA:aIA:aMS", // LED #6 grün
48	".", // LED #7	47	".", // LED #7
49	"aIASSNNNNN", // LED #8 weiss	48	"aIASSNNNNN", // LED #8 weiss
50	".", // LED #9	49	".", // LED #9
51	"NNNaIASSNN" // LED #10 blau	50	"NNNaIASSNN" // LED #10 blau
52	};	51	};
53		52
54	// dasselbe, nur sind w/b dauer-an	53	// dasselbe, nur sind w/b dauer-an
55	char *led_posflash[] = {	54	char *led_posflash[] = {
56	"A", // LED #1 rot	55	"A", // LED #1 rot
57	"A", // LED #2	56	"A", // LED #2
58	"A", // LED #3 blau	57	"A", // LED #3 blau
59	"A", // LED #4	58	"A", // LED #4
60	"A:aIA:aIA:aSV", // LED #5 weiss	59	"A:aIA:aIA:aSV", // LED #5 weiss
61	"NA:aIA:aIA:aMS", // LED #6 grün	60	"NA:aIA:aIA:aMS", // LED #6 grün
62	"A", // LED #7	61	"A", // LED #7
63	"A", // LED #8 weiss	62	"A", // LED #8 weiss
64	"A", // LED #9	63	"A", // LED #9
65	"A" // LED #10 blau	64	"A" // LED #10 blau
66	};	65	};
67		66
68		67
69	char *led_aus[] = {	68	char *led_aus[] = {
70	l_off, // LED #1 rot	69	l_off, // LED #1 rot
71	l_off, // LED #2 blau	70	l_off, // LED #2 blau
72	l_off, // LED #3 blau	71	l_off, // LED #3 blau
73	l_off, // LED #4	72	l_off, // LED #4
74	l_off, // LED #5 weiss	73	l_off, // LED #5 weiss
75	l_off, // LED #6 grün	74	l_off, // LED #6 grün
76	l_off, // LED #7	75	l_off, // LED #7
77	l_off, // LED #8 weiss	76	l_off, // LED #8 weiss
78	l_off, // LED #9	77	l_off, // LED #9
79	l_off // LED #10	78	l_off // LED #10
80	};	79	};
81		80
82	char *led_an[] = {	81	char *led_an[] = {
83	l_on, // LED #1 rot	82	l_on, // LED #1 rot
84	l_on, // LED #2 blau	83	l_on, // LED #2 blau
85	l_on, // LED #3 blau	84	l_on, // LED #3 blau
86	l_on, // LED #4	85	l_on, // LED #4
87	l_on, // LED #5 weiss	86	l_on, // LED #5 weiss
88	l_on, // LED #6 grün	87	l_on, // LED #6 grün
89	l_on, // LED #7	88	l_on, // LED #7
90	l_on, // LED #8 weiss	89	l_on, // LED #8 weiss
91	l_on, // LED #9	90	l_on, // LED #9
92	l_on // LED #10	91	l_on // LED #10
93	};	92	};
94		93
95	// alle LEDs toggeln synchron, 300ms Leucht/Aus-Dauer	94	// alle LEDs toggeln synchron, 300ms Leucht/Aus-Dauer
96	char *led_flash1[] = {	95	char *led_flash1[] = {
97	"aMAM", // LED #1 rot	96	"aMAM", // LED #1 rot
98	"aMAM", // LED #2 blau	97	"aMAM", // LED #2 blau
99	"aMAM", // LED #3 blau	98	"aMAM", // LED #3 blau
100	"aMAM", // LED #4	99	"aMAM", // LED #4
101	"aMAM", // LED #5 weiss	100	"aMAM", // LED #5 weiss
102	"aMAM", // LED #6 grün	101	"aMAM", // LED #6 grün
103	"aMAM", // LED #7	102	"aMAM", // LED #7
104	"aMAM", // LED #8 weiss	103	"aMAM", // LED #8 weiss
105	"aMAM", // LED #9	104	"aMAM", // LED #9
106	"aMAM" // LED #10	105	"aMAM" // LED #10
107	};	106	};
108		107
109	// low Volatage Warning: alle LEDs toggeln synchron, 100ms Leucht/Aus-Dauer	108	// low Volatage Warning: alle LEDs toggeln synchron, 100ms Leucht/Aus-Dauer
110	char *led_lowVolt[] = {	109	char *led_lowVolt[] = {
111	"aIAI", // LED #1 rot	110	"aIAI", // LED #1 rot
112	"aIAI", // LED #2 blau	111	"aIAI", // LED #2 blau
113	"aIAI", // LED #3 blau	112	"aIAI", // LED #3 blau
114	"aIAI", // LED #4	113	"aIAI", // LED #4
115	"aIAI", // LED #5 weiss	114	"aIAI", // LED #5 weiss
116	"aIAI", // LED #6 grün	115	"aIAI", // LED #6 grün
117	"aIAI", // LED #7	116	"aIAI", // LED #7
118	"aIAI", // LED #8 weiss	117	"aIAI", // LED #8 weiss
119	"aIAI", // LED #9	118	"aIAI", // LED #9
120	"aIAI" // LED #10	119	"aIAI" // LED #10
121	};	120	};
122		121
123	// alle LEDs toggeln mit verschiednen Zykluszeiten	122	// alle LEDs toggeln mit verschiednen Zykluszeiten
124	char *led_flash2[] = {	123	char *led_flash2[] = {
125	"a.A.", // LED #1 rot	124	"a.A.", // LED #1 rot
126	"a:A:", // LED #2 blau	125	"a:A:", // LED #2 blau
127	"a;A;", // LED #3 blau	126	"a;A;", // LED #3 blau
128	"aIAI", // LED #4	127	"aIAI", // LED #4
129	"aNAN", // LED #5 weiss	128	"aNAN", // LED #5 weiss
130	"aMAM", // LED #6 grün	129	"aMAM", // LED #6 grün
131	"aMIAMI", // LED #7	130	"aMIAMI", // LED #7
132	"aVAV", // LED #8 weiss	131	"aVAV", // LED #8 weiss
133	"aVIAVI", // LED #9	132	"aVIAVI", // LED #9
134	"aSAS" // LED #10	133	"aSAS" // LED #10
135	};	134	};
136		135
137		136
138	// Hier die zu verwendenden LichtProgramme einfach eintragen.	137	// Hier die zu verwendenden LichtProgramme einfach eintragen.
139		138
140	int current = 0;	139	int current = 0;
141		140
142	void *modes[]= { led_posflash, led_an, led_aus };	141	void *modes[]= { led_posflash, led_posflash1, led_an, led_flash1,led_aus, led_flash2 };
143		142
144	void nextMode(void) {	143	void nextMode(void) {
145		144
146	current = ++current % (sizeof(modes)/sizeof(void *));	145	current = ++current % (sizeof(modes)/sizeof(void *));
147	lprg_init(modes[current]);	146	lprg_init(modes[current]);
148		147
149	}	148	}
150		149
151	ISR(INT1_vect)	150	ISR(INT1_vect)
152	{	151	{
153		152
154	nextMode();	153	nextMode();
155		154
156	}	155	}
157		156
158		157
159	int main(void) {	158	int main(void) {
160		159
161	int tim1s, tim3s, tim10s, analog_state=0;	160	int tim1s, tim3s, tim10s, analog_state=0;
162	int Vcurr;	161	int Vcurr;
163		162
164	SFIOR = 0x00; // Analog Comperator aus	163	SFIOR = 0x00; // Analog Comperator aus
165	ADCSRA = 0xD3; // Converter ein, single	164	ADCSRA = 0xD3; // Converter ein, single
166		165
167	// Ports einstellen	166	// Ports einstellen
168	// Pin B \|7\|6\|5\|4\|3\|2\|1\|0	167	// Pin B \|7\|6\|5\|4\|3\|2\|1\|0
169	// Binär:\|0\|0\|0\|0\|0\|1\|0\|1 (b) => #05 (h)	168	// Binär:\|0\|0\|0\|0\|0\|1\|0\|1 (b) => #05 (h)
170	// Pin B0 und B2 als Ausgänge festlegen	169	// Pin B0 und B2 als Ausgänge festlegen
171	DDRB = 0x05;	170	DDRB = 0x05;
172		171
173	// Pin C \|7\|6\|5\|4\|3\|2\|1\|0	172	// Pin C \|7\|6\|5\|4\|3\|2\|1\|0
174	// Binär:\|0\|0\|1\|1\|1\|1\|1\|0 (b) => #3E (h)	173	// Binär:\|0\|0\|1\|1\|1\|1\|1\|0 (b) => #3E (h)
175	// Pin C1 bis C5 als Ausgänge festlegen	174	// Pin C1 bis C5 als Ausgänge festlegen
176	DDRC = 0x3E;	175	DDRC = 0x3E;
177		176
178	// Pin D \|7\|6\|5\|4\|3\|2\|1\|0	177	// Pin D \|7\|6\|5\|4\|3\|2\|1\|0
179	// Binär:\|1\|1\|1\|1\|0\|0\|0\|0 (b) => #F0 (h)	178	// Binär:\|1\|1\|1\|1\|0\|0\|0\|0 (b) => #F0 (h)
180	DDRD = 0xF0;	179	DDRD = 0xF0;
181	//Pullup für PD3 aktivieren	180	//Pullup für PD3 aktivieren
182	PORTD \|= (1 << PD3);	181	PORTD \|= (1 << PD3);
183		182
184		183
185	//interrupt konfigurueren	184	//interrupt konfigurueren
186	GIMSK = 1<<INT1;	185	GIMSK = 1<<INT1;
187	MCUCR = 1<<ISC10;	186	MCUCR = 1<<ISC10;
188		187
189	ALLES_OFF;	188	ALLES_OFF;
190		189
191	STATUS_ON;	190	STATUS_ON;
192		191
193	Timer_Init();	192	Timer_Init();
194		193
195	lprg_init(modes[current]);	194	lprg_init(modes[current]);
196	tim10s = SetDelay(10000);	195	tim10s = SetDelay(10000);
197	tim3s = SetDelay(3000);	196	tim3s = SetDelay(3000);
198	tim1s = SetDelay(1000);	197	tim1s = SetDelay(1000);
199		198
200		199
201	sei(); //interrupts einschalten	200	sei(); //interrupts einschalten
202		201
203	while (1) {	202	while (1) {
204		203
205	if(flag10ms) { // every 10ms	204	if(flag10ms) { // every 10ms
206	flag10ms = 0;	205	flag10ms = 0;
207	lprg_step(); // next step in light prog	206	lprg_step(); // next step in light prog
208		207
209	if(!analog_state) { // Sampling der SPannung starten	208	if(!analog_state) { // Sampling der SPannung starten
210	ADMUX = 0 \| 0xC0; // Kanal 0, interne Referenz	209	ADMUX = 0 \| 0xC0; // Kanal 0, interne Referenz
211	ADCSRA \|= 0x10; // Ready löschen	210	ADCSRA \|= 0x10; // Ready löschen
212	ADCSRA \|= 0x40; // Start	211	ADCSRA \|= 0x40; // Start
213	analog_state++; // erst wieder sampeln, wenn der Wert ausgelesen wurde	212	analog_state++; // erst wieder sampeln, wenn der Wert ausgelesen wurde
214	}	213	}
215		214
216	}	215	}
217		216
218	// 1s-Task: Status-LED toggeln, Spannung checken	217	// 1s-Task: Status-LED toggeln, Spannung checken
219	if(CheckDelay(tim1s)) {	218	if(CheckDelay(tim1s)) {
220	if (ADCSRA & 0x10) { // Spannungs-Messung beendet?	219	if (ADCSRA & 0x10) { // Spannungs-Messung beendet?
221	ADCSRA = 0xD3;	220	ADCSRA = 0xD3;
222	Vcurr = ADCW; // Wert merken	221	Vcurr = ADCW; // Wert merken
223	analog_state = 0;	222	analog_state = 0;
224	}	223	}
225	if(Vcurr < 180) {	224	if(Vcurr < 180) {
226	lprg_init(led_lowVolt);	225	lprg_init(led_lowVolt);
227	}	226	}
228	if(Vcurr>=180) {	227	if(Vcurr>=180) {
229	lprg_init(modes[current]);	228	lprg_init(modes[current]);
230	}	229	}
231	STATUS_TOGGLE;	230	STATUS_TOGGLE;
232	tim1s = SetDelay(1000);	231	tim1s = SetDelay(1000);
233	}	232	}
234		233
235	// 3s-Task: Unterspannungswarnung ggf. zurücknehmen	234	// 3s-Task: Unterspannungswarnung ggf. zurücknehmen
236	if(CheckDelay(tim3s)) {	235	if(CheckDelay(tim3s)) {
237		236
238	tim3s = SetDelay(3000);	237	tim3s = SetDelay(3000);
239	}	238	}
240		239
241	// 10s-Task: DEMO: programm wechseln	240	// 10s-Task: DEMO: programm wechseln
242	if(CheckDelay(tim10s)) {	241	if(CheckDelay(tim10s)) {
243	// nextMode();	242	nextMode();
244	tim10s = SetDelay(10000);	243	tim10s = SetDelay(10000);
245	}	244	}
246		245
247		246
248		247
249	}	248	}
250		249
251	}	250	}
252		251
253		252
254		253
255		254
256		255
257		256

Subversion Repositories Projects

(root)/MikroBlink/Blitzdings/main.c - Rev 341 → 342