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

Subversion Repositories Projects

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