Kleine draagbare LED kit - 12 PWM LEDs uit een reprogramable ATtiny85 (7 / 8 stap)

Stap 7: Code

Als u wilt gebruiken op een 16 wijzigt MHz Arduino gewoon de "Lus" constante boven tot 128 in plaats van 8.  Deze constante maakt gewoon de code alles een bepaald aantal keren herhalen.  Wij draaien onze ATtiny op 8 MHz, maar ik denk dat de interne klok scheidingslijn moet standaard worden ingesteld omdat het gedraagt zich alsof het draait op 1MHz.

Om een geschikte snelheid, vermenigvuldig deze constante lus omhoog met de snelheid van uw klok (bijvoorbeeld het maken voor een ' 328 waarop de interne 8MHz oscillator 64) enz.  Zorg ervoor dat er altijd een veelvoudig van 8 of de code is waarschijnlijk moeite hebben.

De bijgevoegde code is vrij eenvoudig en heeft slechts 4 modi:

1 - odd & Even afwisselend
2 - scanner met de klok mee
3 - scanner linksom
4 - "Larsen" Typ afwisselend scanner.

Kunt u gemakkelijk veel meer vormen toevoegen en deze kernprogramma duurt slechts rond 1.6K, zodat u een andere 6K + om mee te spelen.

Dezelfde code moet compileren heel goed voor een Arduino ongewijzigd.  Op een Arduino, PB0 aan PB4 zijn digitale "pinnen" 8 tot en met 12 respectievelijk.  Dat wil zeggen 14 tot en met 18 pinnen op de werkelijke ATmega328 of ' 168 chip.  Dit is heel handig voor testdoeleinden of als u zijn coderen terwijl u op onderdelen wacht te komen.

Dit is mijn code:

Schets van de test
Elke LED beurtelings inschakelen
MIT-licentie
Ugi 2012

Dat is mijn standaard-vermenigvuldiger zodat ik kan de schets voor verschillende timing en kloksnelheden tweak.  128 voor Arduino
Maak het een veelvoud van 8!

Const unsigned int lus = 8;

8 tot 12 kaart naar de relevante bits van PORTB op de ' 328, pennen.  Omdat wij direct PORTB opdrachten gebruikt zou moeten dit werken op ' 328 en ATtiny85

Deze maakt gebruik van directe toegang PORTB - thats pinnen D0 te D4 op Tiny Arduino of D8 naar D12 op normale Arduino
Eerste reeks is huidige pin lay-out.
Tweede set is oude versie:
//
Huidige versie:
byte DirMatrix [12] = {B10001, B10001, B10010, B10010, B10100, B10100, B01001, B01001, B01010, B01010, B01100, B01100}; Welke pinnen worden uitgevoerd en die zijn hoge impedence
byte PolMatrix [12] = {B10000, B00001, B10000, B00010, B10000, B00100, B01000, B00001, B01000, B00010, B01000, B00100}; Welke pin is hoog en laag voor elke LED
//
Oude versie:
byte DirMatrix [12] = {B00110, B00110, B01010, B01010, B10010, B10010, B00101, B00101, B01001, B01001, B10001, B10001}; Welke pinnen worden uitgevoerd en die zijn hoge impedence
byte PolMatrix [12] = {B00010, B00100, B00010, B01000, B00010, B10000, B00001, B00100, B00001, B01000, B00001, B10000}; Welke pin is hoog en laag voor elke LED

byte modus = 0; genummerd vanaf nul
Const byte MaxModes = 4; Werkelijke aantal modi (dus 1 als alleen Mode 0 gedefinieerd). Als groter dan 12 moet wijzigen ChangeMode()
Boole SwitchMode = false;
Boole ButtonPress = false; Dit is nu overbodig.

VOID Setup {}

Serial.begin(9600); Er zijn sommige debugging seriële commando's resterende maar commentaar uit.  Ze werken op Ardu' maar niet tiny85
Serial.println ("tiny85 test");
Serial.println ("Ugi 2012");

DDRB & = B11100000; alle pinnen ingesteld op hoge impedence

}

void loop {}
schakelaar (modus) {}
Case 0:
OddEvenFlash();
breken;
Case 1:
Progressive(8,0);
breken;
Case 2:
Progressive(8,1);
breken;
Case 3:
Larsen(8);
breken;
}
Als (SwitchMode) {SwitchMode = false; ChangeMode();}

}

Dit is de centrale routine die een LED licht.
Duurt slechts het nummer van de LED (0 t/m 11)
Gebruik directe poort toegang voor gemak en snelheid
VOID LightLED(byte LEDno) {}
DDRB & = B11100000;  Alle pennen instellen
PORTB & = B11100000; Alle pinnen laag ingesteld
PORTB| = PolMatrix [LEDno]; Stel relevante pinnen hoge & lage
DDRB| = DirMatrix [LEDno]; twee relevante pennen voor uitvoer instellen
}

Controleert de status van de knop.
Roep het niet te vaak ' cos het afval tijd.
Booleaanse CheckButton() {}
DDRB & = B11100000;  Alle pennen instellen
PORTB & = B11100000; Alle pinnen laag ingesteld
PORTB| = B00000100; PB2 hoog - set interne pullup instellen
delayMicroseconds(100); Moet worden toegestaan om af te wikkelen verhoging als problemen met knop druk op
Serial.println (PINB & B00000100);
vluchtige Booleaanse pers = PINB & B00000100;
if(!Press) {/ / als neergehaald door schakelaar
terwijl (! druk op) {/ / wachten tot switch vrijgegeven
Serial.Print ("ontdendering"); Serial.println (PINB & B00000100);
vertraging(20);
Druk op = PINB & B00000100;
}
return true;
}
return false;
}

Voorschotten op de "Mode"-variabele.
VOID ChangeMode() {}
Modus ++;
Als (modus > = MaxModes) modus = 0;
Serial.println(mode);
voor (byte flash = 0; flash < = Mode; flash ++) {}
LightLED(Mode);
delay(5);
DDRB & = B11100000;
delay(15);
}
}

Modus functies hieronder omschreven...

OddEvenFlash - ontworpen als de standaardfunctie.  Dit flitsen en oneven LED afwisselend.
Moet nuttig zijn voor foutopsporing van de hardware, evenals het kijken OK.
VOID OddEvenFlash() {}
Const unsigned int Timer = 300;
ButtonPress = 0;
Booleaanse oneven = false;
terwijl (!. ButtonPress) {}
voor (int unsigned tijd = 0; tijd <(Loop*Timer); tijd ++) {}
voor (byte LED = 0; LED < 12; LED += 2) {}
LightLED(LED+Odd);
}
}
Oneven =! Oneven;
SwitchMode=CheckButton();
Als (SwitchMode) {}
Serial.println ("SwitchMode instellen");
terugkeer;
}
}
}

Progressieve Looping
Stuurt een "oog" van 4 LED's rond de lus door het in-en uitfaden opeenvolgend.
Tweede functie - opnieuw steun hardware foutopsporing & ook ziet er cool!

VOID progressief (byte Increment, Booleaanse Reverse) {}
byte EyePos [4] = {3,2,1,0};
Als (Reverse) {}
EyePos [0] = 8;
EyePos [1] = 9;
EyePos [2] = 10;
EyePos [3] = 11;
}
byte EyeInt[4]={64,192,(192-Increment),(64-Increment)};
terwijl (!. ButtonPress) {}
voor (byte snelheid = 0; Snelheid < lus; Snelheid += 8) {/ / dit moet gelijke snelheid voor clock freq
voor (byte Pos = 0; POS < 4; POS++) {/ / light 4 LEDs volgens hun helderheid
LightLED(EyePos[Pos]);
Serial.Print (EyePos [Pos], DEC); Serial.Print("="); Serial.Print(EyeInt[POS],DEC); Serial.Print("");
byte schroot;
voor (byte Count = 0; Graaf < EyeInt [Pos]; Count++) {PORTB & = B11111111;}
}
Serial.println("");

EyeInt [0] += Increment;
EyeInt [1] += Increment;
EyeInt [2]-= Increment;
EyeInt [3]-= Increment;

Als (EyeInt [3] < Increment) {}
EyeInt [3] = EyeInt [2];
EyeInt [2] = EyeInt [1];
EyeInt [1] = EyeInt [0];
EyeInt [0] = 0;
EyePos [3] = EyePos [2];
EyePos [2] = EyePos [1];
EyePos [1] = EyePos [0];

if(reverse) {}
EyePos [0]--;
Als (EyePos [0] > 200) {EyePos [0] = 11;}
}
else {}
EyePos [0] ++;
Als (EyePos [0] > 11) {EyePos [0] = 0;}
}
SwitchMode=CheckButton();
if(SwitchMode) {terugkeer;}
}
}
}
}

Larsen scanner type Golf
Zou kunnen doen dit als onderdeel van progressieve.  Ik kon het niet maken efficiënt.
VOID Larsen(byte Increment) {}
byte EyePos [4] = {3,2,1,0};
byte EyeInt[4]={64,192,(192-Increment),(64-Increment)};
Booleaanse Reverse = false;
terwijl (!. ButtonPress) {}
voor (byte snelheid = 0; Snelheid < lus; Snelheid += 8) {/ / dit moet gelijke snelheid voor clock freq
voor (byte Pos = 0; POS < 4; POS++) {/ / light 4 LEDs volgens hun helderheid
LightLED(EyePos[Pos]);
Serial.Print (EyePos [Pos], DEC); Serial.Print("="); Serial.Print(EyeInt[POS],DEC); Serial.Print("");
voor (byte Count = 0; Graaf < EyeInt [Pos]; Count++) {PORTB & = B11111111;} / / hold de LED branden gedurende een tijd afhankelijk van de intensiteit van de ogen
}
Serial.println("");
}
EyeInt [0] += Increment;
EyeInt [1] += Increment;
EyeInt [2]-= Increment;
EyeInt [3]-= Increment;

Als (EyeInt [3] < Increment) {}
EyeInt [3] = EyeInt [2];
EyeInt [2] = EyeInt [1];
EyeInt [1] = EyeInt [0];
EyeInt [0] = 0;
EyePos [3] = EyePos [2];
EyePos [2] = EyePos [1];
EyePos [1] = EyePos [0];

if(reverse) {}
EyePos [0]--;
Als (EyePos [0] > 200) {EyePos [0] = 1; Reverse = false;}
}
else {}
EyePos [0] ++;
Als (EyePos [0] > 11) {EyePos [0] = 10; Reverse = true;}
}
SwitchMode=CheckButton();
if(SwitchMode) {terugkeer;}
}
}
}