RGB cykel Rim ljus (9 / 14 steg)

Steg 9: Firmware

Firmware styr RGB rim lamporna. Koden är skriven i Arduino IDE. Gå till http://arduino.cc/ att ladda ner Arduino IDE.

Innan du kan sammanställa och flash koden, måste du också följa efter leda för prydnadssak. Det kräver några tillägg till IDE innan datorn kan kommunicera med prydnadssak. För guiden, gå hit: https://learn.adafruit.com/introducing-trinket/introduction

Med alla dessa saker gjorda, kan du öppna koden. Ladda ner den eller kopiera och klistra in koden nedan för att komma igång. Det finns några saker du kan justera om du vill anpassa din egen rim ljus:

• "OffTime" är den tid som sensorn måste vara avstängd innan hjulet går in i viloläge.

• 'AnimationSpeed' är tiden mellan varje uppdatering av inaktiv animation. 83MS är standard, vilken är en revolution av animation varje sekund (1000ms/12modules = 83.33ms)

/ * < Br > RGB rim ljus firmware V1.00

Den fasta programvaran används för att styra lamporna RGB cykel rim. Använder en TLE4905L Hall effekt sensor (eller andra unipolär Halleffekten sensor)
att mäta varvtalet på ett cykelhjul och lyser upp specifika grupper av RGB lysdioder att alltid tända upp främre vit (framhjul)
och baksidan rött (bakhjul) och har speciella animationer om ville av användaren. RGB modulerna är daisy fastkedjade 74HC595 IC
att köra varje 2 uppsättningar av RGB-lysdioder.

Det är konfigurerbar för något belopp av moduler och animationer.

Denna kod är skriven i hopp om att det kommer att vara användbart, men ingen garuantees.

Skrivet av Y. de Haas, senaste versionen skrivet 24-12-2014 ((som det bör vara) dd-mm-åååå) Ytterligare information om < en href = "http://Ytec3D.com" rel = "nofollow" > http://Ytec3D.com
< /a >

*/
PIN layout
CONST byte LatchPin = 1;
CONST byte VoltagePin = 2;
CONST byte ClockPin = 3;
CONST byte DataPin = 4;
CONST byte HallSensor = 0;

konfigurationer
CONST byte NumOfModules = 6; Mängden 74HC595 moduler daisy kedjas ihop
CONST byte BrightnessStates = 8; Beloppet för ljusstyrka steg. Mer är mer exakt, men lägre frekvens
CONST long OffTime = 2500000; Hur lång tid (us) hall sensorn känner ingenting innan hjulet registrerar som inte rör sig
CONST byte PWMStepTime = 250; Mängden mikrosekunder varje PWM steg tar
CONST byte AnimationSpeed = 83. i millisekunder (standard = 83)

CONST byte CatchUpSpeed = 20; beloppet av millis innan animeringen fångster till hjulet plats av 1/255th av en rotation

CONST ordet LowVoltageThreshold = 725; spänning vid vilken första varning start
CONST ordet LowVoltageBlink [2] = {200, 5000}; på och av för låg spänning
CONST ordet CritVoltageThreshold = 695; spänningen vid som kritisk varning startar
CONST ordet CritVoltageBlink [2] = {200, 1000}; på och av för låg spänning

Animation information
CONST byte AnimationSlots = 5; mängden färger i animeringen (OFF är också en färg)
NumOfAnimations: vad animation, AnimationSlots: mängden definierade färgerna i en animering,
byte LedAnimation [AnimationSlots] [5]. 5: (0) start koordinaten, (1) slutet koordinaten, (2) blå på, (3) rött på, (4) grön på

variabler
ordet WheelLocation = 0;
byte AnimationLocation = 0;
int AnimationLocationOffset = 0, AnimationCurrentOffset = 0;
byte WheelMoving = 0; stater om hjulet är i rörelse eller inte, krävs för att starta
byte PWMState = 0;
byte AnimationState = 12;
byte HallHistory = 1;
byte WheelMovementHistory = 0;
byte VoltageBlinkState = 0;

osignerade långa WheelHistory = 0, WheelSpinTime = 0;
osignerade långa PWMTarget = 0;
osignerade långa AnimationTarget = 0;
osignerade långa CorrectionTarget = 0;
osignerade långa VoltageBlinkTarget = 0;

LedState [n] anges vilken färg varje ledde på varje modul är i "BrightnessStates" intervaller. LedState 0 är avstängd, Ledstate 'BrightnessStates' är full ljusstyrka.
byte LedState [NumOfModules * 2] [3], LedState [n] [0] = blå, LedState [n] [1] = röd och LedState [n] [2] = grön
booleska PWMLedState [NumOfModules * 2] [3], om lysdioderna bör vara på i samband med PWM

byte TempOutputRegister [NumOfModules];

void setup()
{
pinMode (LatchPin, OUTPUT);
pinMode (ClockPin, OUTPUT);
pinMode (DataPin, OUTPUT);
pinMode (VoltagePin, indata);
pinMode (HallSensor, indata); Varning, inverterad, 0 avkänning, 1 inte avkänning.
SetAnimations();
}

void loop()
{
om (WheelMoving == 0 || WheelMoving == 2) //if hjulet går inte eller gör animeringen i staten 2,
{
StationaryAnimation();
WheelMovementHistory = 0;
}

om hall sensorn sinnen, uppdatera hjul stater
om (digitalRead(HallSensor) == 0 & & HallHistory == 1)
{
HallHistory = 0;
om (WheelMoving == 0) //if hjulet inte rörde sig, gå till första revolutionen
{
WheelMoving = 2;
WheelHistory = micros();
}
annat if (WheelMoving == 1) //if hjulet är i stabil rörelse
{
WheelSpinTime = micros() - WheelHistory;
WheelHistory = micros();

bestämma offset baserat på nuvarande plats
AnimationLocationOffset = AnimationLocationOffset + 255 - WheelLocation;
om (AnimationLocationOffset <-127)
{
AnimationLocationOffset += 255;
}
annars om (AnimationLocationOffset > 127)
{
AnimationLocationOffset-= 255;
}

WheelLocation = 0;
}
annat if (WheelMoving == 2) //if hjulet har flyttat en revolution
{
WheelMoving = 1;
WheelSpinTime = micros() - WheelHistory;
WheelHistory = micros();
WheelLocation = 0;
AnimationLocation = 0;
}
}

beräkna hjulet position baserat på hjulet snurra tid och historia
om (WheelMoving == 1)
{
mappa om att 0-255
flyta WheelTemp = micros() - WheelHistory;
WheelTemp = WheelTemp * 255;
WheelTemp = WheelTemp / WheelSpinTime;
WheelLocation = int(WheelTemp);
Kolla är hjulet rörde sig, om inte, matchar hjulet placering till animation plats
om (WheelMovementHistory == 0)
{
WheelMovementHistory = 1;
AnimationLocation = WheelLocation;
}
AnimationLocation = WheelLocation; tillfällig länk hjul läge till animation plats

uppdatera led animation tillstånd, baserat på animation läge
lång TempAnimationLocation;
för (byte jag = 0; jag < NumOfModules * 2; i ++) //for av lysdioder
{
TempAnimationLocation = 256 * i.
TempAnimationLocation = TempAnimationLocation / (NumOfModules * 2);
TempAnimationLocation = AnimationLocation + TempAnimationLocation;
TempAnimationLocation = TempAnimationLocation % 256;
TempAnimationLocation = jag * 21;

beräkna om platsen utifrån vilken modul är på
för (byte j = 0; j < AnimationSlots; j ++) //for mängden färg på animationer
{
om (TempAnimationLocation > = LedAnimation [j] [0] & & TempAnimationLocation < LedAnimation[j][1])
{
LedState [i] [0] = LedAnimation [j] [2].
LedState [i] [1] = LedAnimation [j] [3].
LedState [i] [2] = LedAnimation [j] [4].
}
}
}
}

Återställa Hall historia till 1 om sensorn känner av längre.
om (digitalRead(HallSensor) == 1 & & HallHistory == 0)
{
HallHistory = 1;
}

frångå ledde stater för hälften av lamporna om spänningen är låg eller kritisk
om (analogRead(1) < LowVoltageThreshold)
{
ordet TempVoltage = analogRead(1);
om (millis() > VoltageBlinkTarget)
{
Ange nytt mål
om (TempVoltage > CritVoltageThreshold & & TempVoltage < LowVoltageThreshold)
{
VoltageBlinkTarget = millis() + LowVoltageBlink [VoltageBlinkState];
}
annars om (TempVoltage < CritVoltageThreshold)
{
VoltageBlinkTarget = millis() + CritVoltageBlink [VoltageBlinkState];
}

Ange nytt blink tillstånd
om (VoltageBlinkState == 1)
{
VoltageBlinkState = 0;
}
annat
{
VoltageBlinkState = 1;
}
}

om (VoltageBlinkState == 1)
{
för (byte jag = 0; jag < NumOfModules * 2; i ++)
{
LedState [i] [0] = 0;
LedState [i] [1] = 1;
LedState [i] [2] = 0;
}
}
}

UpdateLeds();

Gå till WheelMoving = 0 om hjulet är stilla för länge
om (WheelMoving == 1 || WheelMoving == 2)
{
om (micros() > WheelHistory + OffTime)
{
WheelMoving = 0;
}
}
}

//Functions ----------------------------------------------------------------------------------------------------------------------
void UpdateLeds()
{
bitWrite (TempOutputRegister [0], 2, LedState[1][0]);
bitWrite (TempOutputRegister [0], 3, LedState[1][1]);
bitWrite (TempOutputRegister [0], 4, LedState[1][2]);
bitWrite (TempOutputRegister [0], 5, LedState[0][0]);
bitWrite (TempOutputRegister [0], 6, LedState[0][1]);
bitWrite (TempOutputRegister [0], 7, LedState[0][2]);

bitWrite (TempOutputRegister [1], 2, LedState[3][0]);
bitWrite (TempOutputRegister [1], 3, LedState[3][1]);
bitWrite (TempOutputRegister [1], 4, LedState[3][2]);
bitWrite (TempOutputRegister [1], 5, LedState[2][0]);
bitWrite (TempOutputRegister [1], 6, LedState[2][1]);
bitWrite (TempOutputRegister [1], 7, LedState[2][2]);

bitWrite (TempOutputRegister [2], 2, LedState[5][0]);
bitWrite (TempOutputRegister [2], 3, LedState[5][1]);
bitWrite (TempOutputRegister [2], 4, LedState[5][2]);
bitWrite (TempOutputRegister [2], 5, LedState[4][0]);
bitWrite (TempOutputRegister [2], 6, LedState[4][1]);
bitWrite (TempOutputRegister [2], 7, LedState[4][2]);

bitWrite (TempOutputRegister [3], 2, LedState[7][0]);
bitWrite (TempOutputRegister [3], 3, LedState[7][1]);
bitWrite (TempOutputRegister [3], 4, LedState[7][2]);
bitWrite (TempOutputRegister [3], 5, LedState[6][0]);
bitWrite (TempOutputRegister [3], 6, LedState[6][1]);
bitWrite (TempOutputRegister [3], 7, LedState[6][2]);

bitWrite (TempOutputRegister [4], 2, LedState[9][0]);
bitWrite (TempOutputRegister [4], 3, LedState[9][1]);
bitWrite (TempOutputRegister [4], 4, LedState[9][2]);
bitWrite (TempOutputRegister [4], 5, LedState[8][0]);
bitWrite (TempOutputRegister [4], 6, LedState[8][1]);
bitWrite (TempOutputRegister [4], 7, LedState[8][2]);

bitWrite (TempOutputRegister [5], 2, LedState[11][0]);
bitWrite (TempOutputRegister [5], 3, LedState[11][1]);
bitWrite (TempOutputRegister [5], 4, LedState[11][2]);
bitWrite (TempOutputRegister [5], 5, LedState[10][0]);
bitWrite (TempOutputRegister [5], 6, LedState[10][1]);
bitWrite (TempOutputRegister [5], 7, LedState[10][2]);

Ange alla led stater till register
digitalWrite (LatchPin, låg);
shiftOut (DataPin, ClockPin, MSBFIRST, TempOutputRegister[0]);
shiftOut (DataPin, ClockPin, MSBFIRST, TempOutputRegister[1]);
shiftOut (DataPin, ClockPin, MSBFIRST, TempOutputRegister[2]);
shiftOut (DataPin, ClockPin, MSBFIRST, TempOutputRegister[3]);
shiftOut (DataPin, ClockPin, MSBFIRST, TempOutputRegister[4]);
shiftOut (DataPin, ClockPin, MSBFIRST, TempOutputRegister[5]);
digitalWrite (LatchPin, hög);
}

void StationaryAnimation()
{
om (millis() > AnimationTarget)
{
Ange nästa mål och uppdatering
AnimationTarget = millis() + AnimationSpeed;
AnimationState ++;
om (AnimationState > 11)
{
AnimationState = 0;
}

animering
för (int jag = 0; jag < 12, i ++)
{
byte temp = i.
Temp += AnimationState;
om (temp > 11)
{
Temp-= 12.
}
om (temp > = 0 & & temp < 1)
{
LedState [i] [0] = 0;
LedState [i] [1] = 1;
LedState [i] [2] = 0;
}
annars om (temp > = 2 & & temp < 4)
{
LedState [i] [0] = 0;
LedState [i] [1] = 1;
LedState [i] [2] = 1;
}
annars om (temp > = 4 & & temp < 6)
{
LedState [i] [0] = 0;
LedState [i] [1] = 0;
LedState [i] [2] = 1;
}
annars om (temp > = 6 & & temp < 8)
{
LedState [i] [0] = 1;
LedState [i] [1] = 0;
LedState [i] [2] = 1;
}
annars om (temp > = 8 & & temp < 10)
{
LedState [i] [0] = 1;
LedState [i] [1] = 0;
LedState [i] [2] = 0;
}
annars om (temp > = 10 & & temp < 12)
{
LedState [i] [0] = 1;
LedState [i] [1] = 1;
LedState [i] [2] = 0;
}
}
}
} < br >
void SetAnimations()
{
avkommentera den animering du vill visa och kommentera andra animeringen
bakhjulet animation
/*
LedAnimation [0] [0] = 60. Start punkt
LedAnimation [0] [1] = 100; slutpunkt
LedAnimation [0] [2] = 1; blå lampan
LedAnimation [0] [3] = 1; röd led
LedAnimation [0] [4] = 1; grön led

LedAnimation [1] [0] = 100; Start punkt
LedAnimation [1] [1] = 140; slutpunkt
LedAnimation [1] [2] = 0; blå lampan
LedAnimation [1] [3] = 1; röd led
LedAnimation [1] [4] = 1; grön led

LedAnimation [2] [0] = 140; Start punkt
LedAnimation [2] [1] = 200. slutpunkt
LedAnimation [2] [2] = 0; blå lampan
LedAnimation [2] [3] = 1; röd led
LedAnimation [2] [4] = 0; grön led

LedAnimation [3] [0] = 200. Start punkt
LedAnimation [3] [1] = 255; slutpunkt
LedAnimation [3] [2] = 0; blå lampan
LedAnimation [3] [3] = 0; röd led
LedAnimation [3] [4] = 0; grön led

LedAnimation [4] [0] = 0; Start punkt
LedAnimation [4] [1] = 60. slutpunkt
LedAnimation [4] [2] = 0; blå lampan
LedAnimation [4] [3] = 0; röd led
LedAnimation [4] [4] = 0; grön led
*/

framhjulet animation

LedAnimation [0] [0] = 40; Start punkt
LedAnimation [0] [1] = 120; slutpunkt
LedAnimation [0] [2] = 1; blå lampan
LedAnimation [0] [3] = 1; röd led
LedAnimation [0] [4] = 1; grön led

LedAnimation [1] [0] = 120; Start punkt
LedAnimation [1] [1] = 150; slutpunkt
LedAnimation [1] [2] = 0; blå lampan
LedAnimation [1] [3] = 1; röd led
LedAnimation [1] [4] = 1; grön led

LedAnimation [2] [0] = 150; Start punkt
LedAnimation [2] [1] = 190; slutpunkt
LedAnimation [2] [2] = 0; blå lampan
LedAnimation [2] [3] = 1; röd led
LedAnimation [2] [4] = 0; grön led

LedAnimation [3] [0] = 190; Start punkt
LedAnimation [3] [1] = 255; slutpunkt
LedAnimation [3] [2] = 0; blå lampan
LedAnimation [3] [3] = 0; röd led
LedAnimation [3] [4] = 0; grön led

LedAnimation [4] [0] = 0; Start punkt
LedAnimation [4] [1] = 40; slutpunkt
LedAnimation [4] [2] = 0; blå lampan
LedAnimation [4] [3] = 0; röd led
LedAnimation [4] [4] = 0; grön led

}