Med en RPi att styra en RGB LED (4 / 5 steg)

Steg 4: Skriva programmet

Innan vi går in det, är det viktigt att notera att indrag är viktigt i Python-språket. Andra språk använder skiljetecken som parentes säga programmet för att köra saker; Python använder indrag. På grund av detta, kan du inte att kunna helt enkelt kopiera och klistra in koden från denna sida till din program som formateringen helt inte bevaras. Du får gärna följa med och skriva egen kod som du gå, eller helt enkelt ladda ner min exempelkod här.

Om du är ny till kodning, är det viktigt att nämna att det finns inte ett sätt att skriva ett program. Människor har sin egen stil, men det kommer mesta till hur du tycker om att lösa ett problem. Jag kommer ge exempelkod och förklara det rad för rad, men tänk på att detta inte är det enda sättet att uppnå exakt samma resultat.

importera sys, tid

Här, importerar vi två inbyggda bibliotek - funktioner, variabler, etc. som redan har definierats och att vi kan ringa på.

importera RPi.GPIO som GPIO

Detta är en Raspbian bibliotek som tillåter oss att använda Python till kontroll GPIO stift.

redPin = 11
greenPin = 13
bluePin = 15

Nu har definiera vi vissa variabler - vilket stift som vi kommer att ansluta till som RGB leder. Detta steg är inte nödvändigt, men det gör det lättare att byta stift om du behöver.

def blink(pin):

Här definierar vi en funktion. En funktion är en uppsättning steg som datorn körs i den ordning som vi ger till den. Denna särskilda funktion kommer att kräva en variabel för att köra: antalet stift som vi vill lysa upp.

GPIO.setmode (GPIO. STYRELSEN)

Vi startar vår funktion genom att referera till en av våra bibliotek, GPIO. Sedan berätta vi det att vi vill välja en namngivningskonvention för GPIO stiften (som det finns två), så att programmet vet vilka som vi hänvisar till. Sedan, vi säger det att använda "styrelsen" konventionen (snarare än BMC konventionen), igen med GPIO biblioteket.

GPIO.setup (pin, GPIO. OUT)

Nu, återigen med hjälp av GPIO biblioteket, vi säga Pi att vi vill använda en PIN-kod. Men först måste vi ange som stift och hur vi vill använda den - ingång eller utgång. Här är "pin" den variabel som kommer att anslutas till blink(pin).

GPIO.output (pin, GPIO. HÖG)

Nu när PIN-koden har lagts upp, vänder den här raden det på. Du bör känna igen syntaxen nu; här använder vi samma variabel "pin" och med hjälp av GPIO biblioteket för att ange PIN-koden till ett värde av "hög". När det gäller GPIO stift, en "hög" värde resulterar i 3.3V överförs eller "på", medan en "låg" uppskattar resultat i 0v överförs, eller "off".

Nu ska vi definiera en funktion om du vill inaktivera lampor. Det kommer att se nästan identisk med den tidigare funktionen, bara vi kommer sätta stiften tillbaka till låg.

def turnOff(pin):
GPIO.setmode (GPIO. STYRELSEN)
GPIO.setup (pin, GPIO. OUT)
GPIO.output (pin, GPIO. LÅG)

Vi måste definiera vissa specifika funktioner till färgen med de funktioner vi just gjort. Minns att vi använder stift 11, 13 och 15 för rött, grönt och blått. Vi börjar med funktioner som vänder lampor på. Med denna typ av funktion, kommer inte vi kräva några parametrar, så hakparenteserna bo tom; kräver denna funktion senare i programmet kommer helt enkelt att köra den.

def redOn():
Blink(redPin)

Här ger vi funktionen "blink" en pin-kod att använda, 11. När vi kallar redOn(), börjar vår blink funktion köra med "pin" ersättas med "redPin". Påminna om att tidigare, vi sätter redPin lika med 11.

Nu gör vi samma sak för resten av färgerna.

def greenOn():
Blink(greenPin)

def blueOn():
Blink(bluePin)

Kom ihåg att när man arbetar med ljus, gul görs genom att blanda röda med grön, cyan med grön och blå, magenta med röda och blå och vit genom att kombinera alla tre.

def yellowOn():
Blink(redPin)
Blink(greenPin)

def cyanOn():
Blink(greenPin)
Blink(bluePin)

def magentaOn():
Blink(redPin)
Blink(bluePin)

def whiteOn():
Blink(redPin)
Blink(greenPin)
Blink(bluePin)

Slutligen skriver vi funktioner om du vill inaktivera lampor. Igen, blir syntaxen liknar funktionerna ovan.

def redOff():
turnOff(redPin)

def greenOff():
turnOff(greenPin)

def blueOff():
turnOff(bluePin)

def yellowOff():
turnOff(redPin)
turnOff(greenPin)

def cyanOff():
turnOff(greenPin)
turnOff(bluePin)

def magentaOff():
turnOff(redPin)
turnOff(bluePin)

def whiteOff():
turnOff(redPin)
turnOff(greenPin)
turnOff(bluePin)

Nu är vi redo att definiera våra huvudsakliga funktion; en slinga som ständigt kommer att be om indata från användaren och reagera genom att ringa olika funktioner. I det här fallet kommer användaren att kunna vända färger på och av. Detta program är skriven så att den endast accepterar några förhand givna indata. Annars kommer den att göra ingenting och Visa ett meddelande om detta.

Återigen, inte ber vi för alla variabler med denna funktion, så hakparenteserna bo tom. "medan True" i huvudsak säger "medan programmet körs, göra detta", så det kommer att köras hela tiden tills vi sluta.

def main ():
samtidigt sant:
CMD = raw_input ("Välj ett alternativ:")

Vi definierar en ny variabel "cmd" för att använda senare och ange det till användarens indata. Det kommer också ständigt uppmanar användaren att välja ett alternativ.

Nu matchar en "om" uttalande som kommer att köras endast om användaren ingång exakt texten inom citattecken. Observera att här använder vi två "lika med" symboler. I Python, och faktiskt de flesta språk används en enda "lika med" för att ändra värdet för en variabel medan dubbel används för att jämföra huruvida variabelvärden matcha varandra.

om cmd == "röd":
redOn()

"elif" står för "annars, om". Detta nubb på det tidigare uttalandet om "om" och lägger till nya parametrar, vilket tillåter oss att skapa en kedja av "annars, om" uttalanden lätt.

Elif cmd == "röd off":
redOff()

Elif cmd == "green på":
greenOn()

Elif cmd == "gröna"
greenOff()

Elif cmd == "blå på":
blueOn()

Elif cmd == "blå":
blueOff()

Elif cmd == "gula på":
yellowOn()

Elif cmd == "gula":
yellowOff()

Elif cmd == "cyan på":
cyanOn()

Elif cmd == "cyan off":
cyanOff()

Elif cmd == "magenta på":
magentaOn()

Elif cmd == "magenta off":
magentaOff()

Elif cmd == "vit på":
whiteOn()

Elif cmd == "vit":
whiteOff()

annat:
skriva ut ("inte ett giltigt kommando.")

returnera

Med vår senaste "else" uttalande, om användaren försöker mata in något annat än en av de kommandon som anges ovan, kommer att det tala om för användaren att det är ett ogiltigt kommando. Den sista funktionen behöver är att "återvända" så att programmet vet när du ska slinga.

Main)

Detta är den sista raden i vår kod. När programmet körs, kommer att denna linje kalla den huvudsakliga funktionen som vi bara definierade och slingan kommer att fastställas.