Nja... alltså rätt eller fel... det kan ju inte vi säga egentligen. Du får ju prova bit för bit och se om det fungerar. Om jag ska testa allt först så blir ju jag tvungen att skriva ett program jag också, som jag dessutom inte har någon möjlighet att testa, eftersom jag inte har ditt kretskort.Har jag gjort helt fel och inte alls som Jesse tänkte? Eller var det helt rätt och ni blev helt förstummade?
verkar OK. Börja med ljusstyrka och tid. Automatik för dimning kan man lägga till senare, så att man inte krånglar till det i onödan till en början.I anropet skickas ljusstyrka och tid, (eventuellt skickar man här också data för dimning, om man lyckas få till en automation för detta i funktionen. Då behövs om den ska upp/ner dimmas, tiden avgörs av hur länge den bilden ska visas.).
Det kan nog fungera, men fundera på vad jag skrivit om bithantering. Du kan skicka data med tre bytes för en rad: röd (åtta bitar), blå (åtta bitar) och grön (åtta bitar). Det blir i praktiken tre instruktioner:Den plockar ut åtta nummer för att avgöra vilka färger på respektive plats som ska tändas. (Här kommer troligen for-sats 2, och eventuellt for-sats 3.)
Kod: Markera allt
RED = red[row];
GREEN = green[row];
BLUE=blue[row];Kod: Markera allt
uint8_t monster[] = { rad0_röd, rad0_grön, rad0_blå, rad1_röd, rad1_grön, rad1_blå, rad2_röd, rad2_grön, rad2_blå .... osv... till rad5_blå };Kod: Markera allt
uint8_t monster[] = { 0b00110,0b00110,0b00000, 0b11001,0b00000,0b11000, osv... };Jag antar att du inte tänker använda interrupt i den här versionen. Då blir det for-loopar. Men då är for-sats nr 1 inte den som går igenom rad för rad, utan den som anger hur länge mönstret ska visas (tid). Inuti denna kommer for-satsen som stegar fram rad för rad. Varje gång du börjar på rad noll måste du börja läsa arrayen från början igen. Enklast är nog att du före den for-satsen skapar en index-variabel , t.ex. uint8_t j = 0; som du sedan inkrementerar varje gång du läser ett tal:For-satts nr 1 används för att stega igenom pixlarna radvis.
Kod: Markera allt
RED = monster[j++];
GREEN = monster[j++];
BLUE=monster[j++];Kod: Markera allt
svart = rgb 0,0,0 = 0b000 = 0
röd = rgb 1,0,0 = 0b100 = 4
grön = rgb 0,1,0 = 0b010 = 2
blå = rgb 0,0,1 = 0b001 = 1
gul = rgb 1,1,0 = 0B110 = 6
...osv... 
Det ska nog fungera bra.I huvud for-satsen borde man också kunna ha en if-sats eller liknande, som reagerar om dimnings-talet inte är noll. Denna stegar då upp eller ned hur mycket svart paus det ska vara emellan raderna.
Den bör nog också samtidigt stega hur länge färgen ska vara tänd.
Detta borde kunna fungera som dimning för hela skärmen samtidigt.
Kod: Markera allt
monster[] = {0,1,2,3,4,5,6,7,
0,1,2,3,4,5,6,7,
0,1,2,3,4,5,6,7,
0,1,2,3,4,5,6,7,
0,1,2,3,4,5,6,7,
0,1,2,3,4,5,6,7};
Kod: Markera allt
uint8_t PROGMEM monster[3][20] = { // 3 = antal mönster, 20 = antal databytes i varje mönster
// mönster noll
{ 0,1,2,3,4,5,6,7,
0,1,2,3,4,5,6,7,
0,1,2,3,4,5,6,7,
0,1,2,3,4,5,6,7,
0,1,2,3,4,5,6,7,
0,1,2,3,4,5,6,7}
// mönster ett
{ 0,1,2,3,4,5,6,7,
0,1,2,3,4,5,6,7,
0,1,2,3,4,5,6,7,
0,1,2,3,4,5,6,7,
0,1,2,3,4,5,6,7,
0,1,2,3,4,5,6,7}
// mönster två
{ 0,1,2,3,4,5,6,7,
0,1,2,3,4,5,6,7,
0,1,2,3,4,5,6,7,
0,1,2,3,4,5,6,7,
0,1,2,3,4,5,6,7,
0,1,2,3,4,5,6,7}
// slut på mönster
}Kod: Markera allt
colour = pgm_read_byte(monster[nummer,i]);Kod: Markera allt
while(1) { // ...loopa för evigt...
monster[0] = {0,1,2,3,4,5,6,7,
0,1,2,3,4,5,6,7,
0,1,2,3,4,5,6,7,
0,1,2,3,4,5,6,7,
0,1,2,3,4,5,6,7,
0,1,2,3,4,5,6,7};
refrech();// red, green, blue
}Kod: Markera allt
uint8_t monster[48] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; Kod: Markera allt
uint8_t monster[48];
int main() {
...
monster[0] = 7;
monster[1] = 4;
monster[2] = 3;
....osv...Kod: Markera allt
//---------------- standardbibliotek ------------------
// #define F_CPU 8000000 för att använda intern 8 MHz osilator
#include <avr/io.h>
#include <util/delay.h>
#include <util/delay_basic.h>
#define CLOCK (1<<PB1)
#define ROW PORTF
#define RED PORTA
#define GREEN PORTC
#define BLUE PORTD
uint8_t steg;
uint8_t pixelnr;
uint8_t tid = 1;
uint8_t ROWNR;
uint8_t monster[48];
uint8_t red = 0b11100000;
uint8_t green = 0b00011100;
uint8_t blue = 0b00000011;
void refrech() { // SKRIV ALGORITM HÄR
for(uint8_t z = 0; z < tid; z++){ //Om man vill köra mönstret mer än 1 varv
ROWNR = 0b00000001; //Bestämmer vilken rad som ska skickas ut, stegas upp var 8:e pixel.
pixelnr = 0; //Bestämmer vilken mönsterpixel som ska plockas ut och användas
steg = 0; //Används för att ha koll på var 8 pixel, när red/green/blue är fulla ska de skickas ut.
for(;pixelnr < 48; pixelnr++){ //När pixelnr går över 47 så tar det slut. (pixelnr < 8*ROWNR+8 &&)
if(monster[pixelnr] < 4){
if(monster[pixelnr] < 2){
if(monster[pixelnr] < 1){ //0 = Svart
red >> 1;
green << 1;
blue << 1;
}
else{ //1 = blå
red >> 1;
green << 1;
blue << 1;
blue | 0b00000001;
}
}
else{
if(monster[pixelnr] < 3){ //2 = grön
red >> 1;
green << 1;
blue << 1;
green | 0b00000001;
}
else{ //3 = turkos
red >> 1;
green << 1;
blue << 1;
green | 0b00000001;
blue | 0b00000001;
}
}
}
else{
if(monster[pixelnr] < 6){
if(monster[pixelnr] < 5){ //4 = röd
red >> 1;
green << 1;
blue << 1;
red | 0b10000000;
}
else{ //5 = lila
red >> 1;
green << 1;
blue << 1;
red | 0b10000000;
blue | 0b00000001;
}
}
else{
if(monster[pixelnr] < 7){ //6 = gul
red >> 1;
green << 1;
blue << 1;
red | 0b10000000;
green | 0b00000001;
}
else{ //7 = vit
red >> 1;
green << 1;
blue << 1;
red | 0b10000000;
green | 0b00000001;
blue | 0b00000001;
}
}
}
if(pixelnr == 7+steg){ // Skickar var 8:e steg ut en rad
//red = 0b11111111; - Används för vid vissa test, för att kunna sätta alla pixlar på en rad
//green = 0b00000000;
//blue = 0b00000000;
ROW = ROWNR; //Tänder en rad
RED = red; //Tänder de röda som skas vara tända på raden
GREEN = green; //Tänder de gröna som skas vara tända på raden
BLUE = blue; //Tänder de blå som skas vara tända på raden
steg = steg+8; //Bestämmer vilken nästa pixel för radbyta är. Tillsammans med ovanstående if-sats.
_delay_us(10);
ROWNR << 1; //Stegar till nästa rad,
}
}
}
}
/**** huvudprogrammet ****/
int main(void) {
// initiering av portar (se kapitel 12 i databladet - särskilt 12.2.1)
DDRF = 0b00000000; // alla pinnar på port F ska vara utgångar rad
DDRA = 0b11111111; // alla pinnar på port A ska vara utgångar röd
DDRC = 0b11111111; // alla pinnar på port C ska vara utgångar grön
DDRD = 0b11111111; // alla pinnar på port D ska vara utgångar blå
PORTF = 0b11111111; //aktiverar alla rader
while(1) { // ...loopa för evigt...
monster[0] = 2; monster[1] = 1; monster[2] = 2; monster[3] = 3; monster[4] = 4; monster[5] = 5; monster[6] = 6; monster[7] = 7;
monster[8] = 2; monster[9] = 1; monster[10] = 2; monster[11] = 3; monster[12] = 4; monster[13] = 5; monster[14] = 6; monster[15] = 7;
monster[16] = 2; monster[17] = 1; monster[18] = 2; monster[19] = 3; monster[20] = 4; monster[21] = 5; monster[22] = 6; monster[23] = 7;
monster[24] = 2; monster[25] = 1; monster[26] = 2; monster[27] = 3; monster[28] = 4; monster[29] = 5; monster[30] = 6; monster[31] = 7;
monster[32] = 2; monster[33] = 1; monster[34] = 2; monster[35] = 3; monster[36] = 4; monster[37] = 5; monster[38] = 6; monster[39] = 7;
monster[40] = 2; monster[41] = 1; monster[42] = 2; monster[43] = 3; monster[44] = 4; monster[45] = 5; monster[46] = 6; monster[47] = 7;
//^Tillfälligt för teststadiet, för att kunna byta mönster - ska senare finnas i PROGMEM
//0 = svart, blå = 1, 2 = grön, 3 = cyan, 4 = röd, 5 = magenta, 6 = gul, 7 = vit - enligt tidigare förslag om färglogik.
refrech(); //Anropar refrech för att få nytt mönster
_delay_ms(1000);
}
}
Kod: Markera allt
red >> 1;
green << 1;
blue << 1;
blue | 0b00000001;Kod: Markera allt
red >>= 1;
green <<= 1;
blue <<= 1;
blue |= 0b00000001;
Kod: Markera allt
switch(monster[pixelnr]) {
case 0: // svart
kod...
break;
case 1: // röd
kod...
break;
case 2: // grön
kod...
break;
}Kod: Markera allt
red <<= 1;
green <<= 1;
blue <<= 1;
if (monster[pixelnr] & 1) blue |= 1;
if (monster[pixelnr] & 2) green |= 1;
if (monster[pixelnr] & 4) red |= 1;
