Interupted Wallpapers
Datum: Sun 16 March 2014
Samenvatting: Ge-interupt Behang op de panelen.
De twee vorige programma's ("Random Figuren" en "Interupt en 8 Led's") zijn met elkaar gecombineerd. Op zich duurde het combineren kort, maar wat een genot om trillingsvrij beeld te hebben EN een korte [loop()] funktie.
Het initialiseren van de timer is, om het overzichtelijk te houden, in een aparte funktie geplaatst, genaamd [InitTimer()]. Dit is dezelfde funktie als in het [Interupt en 8 Led's] projekt. En uiteraard is er geëxperimenteerd met de timer-waarde in de regel:
| OCR1A = 5200; // set Output Compare Register 1 to the desired timer count |
Wordt dit getal te klein, dan bljft er te weinig tijd over voor het hoofdprogramma vlot te laten lopen. Als dit getal veel te klein wordt, dan zou het hoofdprogramma helemaal geen tijd meer krijgen.
Wordt dit getal te groot, dan gaat het beeld weer (irritant) knipperen. Als dit getal echter veel te groot wordt, dan wordt het zichtbaar dat het beeld echt lijn voor lijn wordt getoond.
Experimenteel zijn de volgende getallen gevonden (afgerond op 100-tallen):
| Prescaler = 1 (0b0000 0001) | |
lager dan
3300 | Stap voor stap opbouw van het behang. |
3400
3300 | Het behang wordt zichtbaar, doch vloeiend opgebouwd. |
3600
5600 | Opbouw in 1 keer, knippervrij beeld. |
6000
en hoger | Knipperend beeld. Hoe hoger, hoe irritanter het knipperen wordt. |
Geen grenswaarde bepaald
50000 en hoger | Het beeld wordt lijn voor lijn (per 2 lijnen) getoond. |
De eigenlijke beeldopbouw funktie [IntOneRow()] heeft een andere naam moeten krijgen [ISR(TIMER1_COMPA_vect)]. Dezelfde naam als beschreven wordt in de vele voorbeelden.
Het programma
Voor veel funkties verwijs ik naar het project van Random Figuren. Er is hier wel wat bijgekomen.
Bgcolor - de achtergrondkleur
Voor de achtergrondkleur is de variabele [bgcolor] aangepast. De eigenlijke variabele heet nu [_bgcolor]. De inhoud ervan kan worden veranderd door de funktie [Setbgcolor] (en doet meteen een kleine controle). Deze kan worden uitgelezen met [bgcolor()].
Aanvullingen
Natuurlijk heb ik weer creatieve uitbreidingen aangebracht met de drie potmeters (nr 4, 5, 6).
- Potmeter 6: is geprogrammeerd voor de wisselsnelheden van de wallpapers.
- Potmeter 5: heeft de achtergrondkleur als funktie gekregen en wel in puur RGB/CYMW (dus inclusief de binaire mengkleuren van RGB: CYMW), inclusief hun 8 tinten (inclusief Zwart).
- Potmeter 4: zorgt voor de achtergrond in 4 standen: wisselen, behang 1, behang 2, alleen achtergrondkleur.
Eind conclusie
Als eindconclusie is te stellen dat mijn einddoel wel gehaald is. De RGB-Panelen heb ik aangestuurd gekregen. En hierbij wordt een interupt gebruikt. Wat nu rest is het in een eigen library stoppen van deze aansturing.
Daarna zijn projekten te maken om de panelen nuttig in te zetten. Daar vallen ook character-schrijvende funkties onder.
Broncode:
[1: Interupted Wallpapers]
1: De broncode van Interupted Wallpapers
(Sat 03 May 2014)
|
Deze broncode heeft 349 regels met programma-code.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
|
// ---------------------------------------------------------
// | Experimentation Kit for Arduino Example Code |
// | RGBMatrix : RGB Matrix - Interupted WallPapers |
// ---------------------------------------------------------
// Some Pot-vars
word pot_del = 0;
word pot_kleur = 0;
word pot_num = 0;
byte wp_count = 0;
void setup()
{ InitPan(0x0777);
wp_count = 0;
Serial.begin(115200);
}
void loop()
{ read_pots();
switch (wp_count)
{ case 0 : Behang1();
break;
case 1 : Behang2();
break;
case 2 : ClrPan();
break;
}
delay (pot_del);
Setbgcolor (pot_kleur);
switch (pot_num)
{ case 0 : wp_count = wp_count + 1;
if (wp_count > 1)
{ wp_count=0; }
break;
case 1 : wp_count = 0;
break;
case 2 : wp_count = 1;
break;
case 3 : wp_count = 2;
break;
}
}
void read_pots()
{ const word kleurwaaier [8] = {0x0000, 0x0001, 0x0010, 0x0011, 0x0100, 0x0101, 0x0110, 0x0111};
word pot_kleur_hi = 0;
word pot_kleur_lo = 0;
pot_del = analogRead(5) * 16;
word pot_kleur_pot = analogRead(4) / 16;
pot_kleur_lo = ( pot_kleur_pot & 0x0007 ); // 0b 0000 0111
pot_kleur_hi = ( pot_kleur_pot & 0x0038 ) >> 3; // 0b 0011 1000
while (pot_kleur_hi == 0)
{ // When main-color is black => take a random color
pot_kleur_hi = random(7) +1;
}
pot_kleur = kleurwaaier[pot_kleur_hi] * pot_kleur_lo ;
pot_num = analogRead(3) / 256;
}
void Behang1()
{ for ( byte qy=0; qy<=15; qy=qy+1 )
{ for ( byte qx=0; qx<=63; qx=qx+2 )
{ word qk = Dec2RGB ( ( 8 * qx ) + qy );
SetPoint (qx ,qy, qk );
SetPoint (qx+1,qy, qk );
}
}
}
void Behang2()
{
// Zwart
Cirkel ( 0+ 0 , 0+ 0 , 0x0000 );
Cirkel ( 0+ 4 , 0+ 0 , 0x0000 );
Cirkel ( 0+ 8 , 0+ 0 , 0x0000 );
Cirkel ( 0+12 , 0+ 0 , 0x0000 );
Cirkel ( 0+ 0 , 0+ 4 , 0x0000 );
Cirkel ( 0+ 4 , 0+ 4 , 0x0000 );
Cirkel ( 0+ 8 , 0+ 4 , 0x0000 );
Cirkel ( 0+12 , 0+ 4 , 0x0000 );
// Blauw
Cirkel ( 16+ 0 , 0+ 0 , 0x0000 );
Cirkel ( 16+ 4 , 0+ 0 , 0x0001 );
Cirkel ( 16+ 8 , 0+ 0 , 0x0002 );
Cirkel ( 16+12 , 0+ 0 , 0x0003 );
Cirkel ( 16+ 0 , 0+ 4 , 0x0004 );
Cirkel ( 16+ 4 , 0+ 4 , 0x0005 );
Cirkel ( 16+ 8 , 0+ 4 , 0x0006 );
Cirkel ( 16+12 , 0+ 4 , 0x0007 );
// Groen
Cirkel ( 32+ 0 , 0+ 0 , 0x0000 );
Cirkel ( 32+ 4 , 0+ 0 , 0x0010 );
Cirkel ( 32+ 8 , 0+ 0 , 0x0020 );
Cirkel ( 32+12 , 0+ 0 , 0x0030 );
Cirkel ( 32+ 0 , 0+ 4 , 0x0040 );
Cirkel ( 32+ 4 , 0+ 4 , 0x0050 );
Cirkel ( 32+ 8 , 0+ 4 , 0x0060 );
Cirkel ( 32+12 , 0+ 4 , 0x0070 );
// Cyan
Cirkel ( 48+ 0 , 0+ 0 , 0x0000 );
Cirkel ( 48+ 4 , 0+ 0 , 0x0011 );
Cirkel ( 48+ 8 , 0+ 0 , 0x0022 );
Cirkel ( 48+12 , 0+ 0 , 0x0033 );
Cirkel ( 48+ 0 , 0+ 4 , 0x0044 );
Cirkel ( 48+ 4 , 0+ 4 , 0x0055 );
Cirkel ( 48+ 8 , 0+ 4 , 0x0066 );
Cirkel ( 48+12 , 0+ 4 , 0x0077 );
// Rood
Cirkel ( 0+ 0 , 8+ 0 , 0x0000 );
Cirkel ( 0+ 4 , 8+ 0 , 0x0100 );
Cirkel ( 0+ 8 , 8+ 0 , 0x0200 );
Cirkel ( 0+12 , 8+ 0 , 0x0300 );
Cirkel ( 0+ 0 , 8+ 4 , 0x0400 );
Cirkel ( 0+ 4 , 8+ 4 , 0x0500 );
Cirkel ( 0+ 8 , 8+ 4 , 0x0600 );
Cirkel ( 0+12 , 8+ 4 , 0x0700 );
// Magenta
Cirkel ( 16+ 0 , 8+ 0 , 0x0000 );
Cirkel ( 16+ 4 , 8+ 0 , 0x0101 );
Cirkel ( 16+ 8 , 8+ 0 , 0x0202 );
Cirkel ( 16+12 , 8+ 0 , 0x0303 );
Cirkel ( 16+ 0 , 8+ 4 , 0x0404 );
Cirkel ( 16+ 4 , 8+ 4 , 0x0505 );
Cirkel ( 16+ 8 , 8+ 4 , 0x0606 );
Cirkel ( 16+12 , 8+ 4 , 0x0707 );
// Geel
Cirkel ( 32+ 0 , 8+ 0 , 0x0000 );
Cirkel ( 32+ 4 , 8+ 0 , 0x0110 );
Cirkel ( 32+ 8 , 8+ 0 , 0x0220 );
Cirkel ( 32+12 , 8+ 0 , 0x0330 );
Cirkel ( 32+ 0 , 8+ 4 , 0x0440 );
Cirkel ( 32+ 4 , 8+ 4 , 0x0550 );
Cirkel ( 32+ 8 , 8+ 4 , 0x0660 );
Cirkel ( 32+12 , 8+ 4 , 0x0770 );
// Wit
Cirkel ( 48+ 0 , 8+ 0 , 0x0000 );
Cirkel ( 48+ 4 , 8+ 0 , 0x0111 );
Cirkel ( 48+ 8 , 8+ 0 , 0x0222 );
Cirkel ( 48+12 , 8+ 0 , 0x0333 );
Cirkel ( 48+ 0 , 8+ 4 , 0x0444 );
Cirkel ( 48+ 4 , 8+ 4 , 0x0555 );
Cirkel ( 48+ 8 , 8+ 4 , 0x0666 );
Cirkel ( 48+12 , 8+ 4 , 0x0777 );
}
void Vierkant (byte x, byte y, word k)
{ SetPoint (x+0, y+0, k );
SetPoint (x+0, y+1, k );
SetPoint (x+0, y+2, k );
SetPoint (x+0, y+3, k );
SetPoint (x+1, y+0, k );
SetPoint (x+1, y+1, k );
SetPoint (x+1, y+2, k );
SetPoint (x+1, y+3, k );
SetPoint (x+2, y+0, k );
SetPoint (x+2, y+1, k );
SetPoint (x+2, y+2, k );
SetPoint (x+2, y+3, k );
SetPoint (x+3, y+0, k );
SetPoint (x+3, y+1, k );
SetPoint (x+3, y+2, k );
SetPoint (x+3, y+3, k );
}
void Cirkel (byte x, byte y, word k )
{ SetPoint (x+0, y+0, bgcolor() );
SetPoint (x+0, y+1, k );
SetPoint (x+0, y+2, k );
SetPoint (x+0, y+3, bgcolor() );
SetPoint (x+1, y+0, k );
SetPoint (x+1, y+1, k );
SetPoint (x+1, y+2, k );
SetPoint (x+1, y+3, k );
SetPoint (x+2, y+0, k );
SetPoint (x+2, y+1, k );
SetPoint (x+2, y+2, k );
SetPoint (x+2, y+3, k );
SetPoint (x+3, y+0, bgcolor() );
SetPoint (x+3, y+1, k );
SetPoint (x+3, y+2, k );
SetPoint (x+3, y+3, bgcolor() );
}
//==============================================================================
//== ==
//==============================================================================
// Paneel Vars.
const byte MaxCol = 64;
volatile byte PanelData [MaxCol][8][3]; // = [00..63],[0..7],[0..2] of (Rl Gl Bl Ru Gu Bu 0 0)
volatile byte RowCount = 0;
// Brightness Vars.
const byte MaxBrightCount = 9; // Count 1..MaxBrightCount
const byte BrightRow [MaxBrightCount] = {0,2,2,1,2,2,1,2,2}; // Counter Conversion for Binairy Code Modulation.
volatile byte BrightCount = 0;
// BackGround-Color (format: 0x0RGB = B 0000 RRRR GGGG BBBB)
word _bgcolor = 0x0000;
// RGB Pin Definitions - All Pins are hardcoded to speed things up.
// const int a = A0; // Address A (A0)
// const int b = A1; // Address B (A1)
// const int c = A2; // Address C (A2)
// const int b1 = 2; // Blue 1
// const int g1 = 3; // Green 1
// const int r1 = 4; // Red 1
// const int b2 = 5; // Blue 2
// const int g2 = 6; // Green 2
// const int r2 = 7; // Red 2
// const int clk = 8; // Clock
// const int oe = 9; // outEnable
// const int lat = 10; // Latch
void InitPan(word _k)
// Initializing the Panel
// Input: _k = BackGround-Color (format: 0x0RGB = B 0000 0RRR 0GGG 0BBB)
{ // Put Pins to Output (A0 A1 A2 - D2 D3 D4 - D5 D6 D7 - D8 D9 D10)
DDRC = DDRC | B00000111; // pinMode(a , OUTPUT); pinMode(b , OUTPUT); pinMode(c , OUTPUT);
DDRD = DDRD | B11111100; // pinMode(r1 , OUTPUT); pinMode(g1 , OUTPUT); pinMode(b1 , OUTPUT);
// pinMode(r2 , OUTPUT); pinMode(g2 , OUTPUT); pinMode(b2 , OUTPUT);
DDRB = DDRB | B00000111; // pinMode(clk, OUTPUT); pinMode(oe , OUTPUT); pinMode(lat, OUTPUT);
Setbgcolor(_k);
ClrPan();
InitTimer();
}
void InitTimer()
{ // Initialize Timer1
cli(); // Disable Interrupts
// Timer Counter Control Registers 1A & 1B
TCCR1A = 0; // Make all bits of this register to 0
TCCR1B = 0; // Make all bits of this register to 0
OCR1A = 3900; // set Output Compare Register 1 to the desired timer count
TCCR1B = TCCR1B | B00001000; // turn on CTC mode (WGM12 = bit 3 - Waveform Generation Mode)
TCCR1B = TCCR1B | B00000001; // Set the Prescaler (CS12 CS11 CS10 = bit 2..0 - Clock Select)
TIMSK1 = TIMSK1 | B00000010; // set Timer Interupt MaSK 1 to compare interrupt
// (OCIE1A = bit 1 - Output Compare match Interrupt Enable 1A)
sei(); // Enable Interrupts
}
void Setbgcolor(word _k)
{ // BackGround-Color (format: 0x0RGB = B 0000 0RRR 0GGG 0BBB)
_bgcolor = _k & 0x0777;
}
word bgcolor(void)
{ return _bgcolor;
}
void ClrPan()
// Clear the Panel with bgcolor
{ byte _lc = ( LowColor(bgcolor()) * 9 ) << 2;
byte _mc = ( MidColor(bgcolor()) * 9 ) << 2;
byte _hc = ( HighColor(bgcolor()) * 9 ) << 2;
for (byte ww=0; ww<8; ww=ww+1)
{ for (byte qq=0; qq<MaxCol; qq=qq+1)
{ PanelData [qq][ww][0] = _lc;
PanelData [qq][ww][1] = _mc;
PanelData [qq][ww][2] = _hc;
}
}
}
byte LowColor (word _k)
// Get the LowColor rgb from 0000 0RRR 0GGG 0BBB
{ return (( _k & 0x0100 ) >> 6 ) + (( _k & 0x0010 ) >> 3 ) + (( _k & 0x0001 ) );
}
byte MidColor (word _k)
// Get the MidColor RGB from 0000 0RRR 0GGG 0BBB
{ return (( _k & 0x0200 ) >> 7 ) + (( _k & 0x0020 ) >> 4 ) + (( _k & 0x0002 ) >> 1 );
}
byte HighColor (word _k)
// Get the HighColor RGB from 0000 0RRR 0GGG 0BBB
{ return (( _k & 0x0400 ) >> 8 ) + (( _k & 0x0040 ) >> 5 ) + (( _k & 0x0004 ) >> 2 );
}
word Dec2RGB (word _k)
// Convert a decimal color into a hex RGB-color 0000 0RRR 0GGG 0BBB
{ return (( _k & 0x01C0 ) << 2 ) + (( _k & 0x0038 ) << 1 ) + ( _k & 0x0007 );
}
void SetPoint (byte _x, byte _y, word _k)
// Let one Led lit at the (x;y) position
{ _x = ( _x & 0x3F );
_y = ( _y & 0x0F ) ^ 0x0F; // y = ( y and $0F ) xor $0F
byte _y7 = _y & 0x07;
_k = _k & 0x0777;
byte _lc = LowColor(_k);
byte _mc = MidColor(_k);
byte _hc = HighColor(_k);
// Put The Pixel On The Right Spot.
if (( _y & 0x08 ) == 0 )
{ // This is the Upper-half
PanelData[_x][_y7][0] = ( PanelData[_x][_y7][0] & B11100000 ) | ( _lc << 2 );
PanelData[_x][_y7][1] = ( PanelData[_x][_y7][1] & B11100000 ) | ( _mc << 2 );
PanelData[_x][_y7][2] = ( PanelData[_x][_y7][2] & B11100000 ) | ( _hc << 2 );
}
else
{ // This is the Lower half.
PanelData[_x][_y7][0] = ( PanelData[_x][_y7][0] & B00011100 ) | ( _lc << 5 );
PanelData[_x][_y7][1] = ( PanelData[_x][_y7][1] & B00011100 ) | ( _mc << 5 );
PanelData[_x][_y7][2] = ( PanelData[_x][_y7][2] & B00011100 ) | ( _hc << 5 );
}
}
ISR(TIMER1_COMPA_vect)
// De Interrupt Service Routine
// The main interupt-routine. Do One Row (at each Interupt)
{ byte rc = MaxCol;
byte BrightLayer = BrightRow[BrightCount];
byte _clock_rise = PORTB | B00000001; // digitalWrite(clk, HIGH);
byte _clock_fall = PORTB & B11111110; // digitalWrite(clk, LOW );
byte _data_serial = ( PORTD & B00000011 );
do { rc=rc-1;
// Send the RGB to the RGB-lines
PORTD = _data_serial | PanelData[rc][RowCount][BrightLayer];
// Clock the RGB
PORTB = _clock_rise;
PORTB = _clock_fall;
} while (rc>0);
// Make it Invisible
PORTB = PORTB | B00000010; // digitalWrite(oe , HIGH);
// Select the Row on the panels.
PORTC = ( PORTC & B11111000 ) | RowCount;
// Latch the Data
PORTB = PORTB | B00000100; // digitalWrite(lat, HIGH);
PORTB = PORTB & B11111011; // digitalWrite(lat, LOW );
// Make it Visible again
PORTB = PORTB & B11111101; // digitalWrite(oe , LOW );
// Next Row
RowCount = RowCount + 1; // Count the Row
if ( RowCount >= 8 )
{ RowCount = 0;
BrightCount = BrightCount + 1; // Inc the Brightness counter
if ( BrightCount >= MaxBrightCount )
{ BrightCount = 0;
}
}
|
Broncode:
[1: Interupted Wallpapers]
|
Afbeeldingen
1/2: intwalpa_1.jpg.
2/2: intwalpa_2.jpg.
|
De aansluitingen van Interupted Wallpapers
Arduino Uno
|
|
|
Pwr USB
|
?
|
|
|
|
|
|
?
|
|
|
|
|
aref
|
|
|
|
|
gnd
|
Gnd's (4x)
|
|
|
?
|
d13
|
|
|
|
ioreff
|
d12
|
|
|
|
reset
|
d11
|
|
|
|
+3.3v
|
d10
|
Latch
|
|
|
+5v
|
d9
|
Oe
|
|
Gnd's (4x)
|
gnd
|
d8
|
Clock
|
|
Gnd's (4x)
|
gnd
|
|
|
|
|
Vin
|
d7
|
R2
|
|
|
|
d6
|
G2
|
|
A (A0)
|
a0
|
d5
|
B2
|
|
B (A1)
|
a1
|
d4
|
R1
|
|
C (A2)
|
a2
|
d3
|
G1
|
|
Behangpot (4)
|
a3
|
d2
|
B1
|
|
Kleurpot (5)
|
a4
|
d1
|
|
|
Snelheidpot (6)
|
a5
|
d0
|
|
|
Arduino Projekten
