Reflexväst med blinkers

I detta projekt ska vi bygga in riktningsindikatorer i en reflexväst! Då kan man visa tydligt vart man är på väg när man rider häst eller cyklar.

Vad du behöver

Material

Verktyg

  • Nål
  • Sax
  • Micro-USB sladd
  • Dator

Vad är det här för lampor?

Neopixels är ett namn för en typ av LED-lampor som kan ha olika färger, och kan kopplas ihop på rad så att bara en output behövs för att styra (nästan oändligt) många. Man ser dom på olika uppsättningar, såsom långa remsor, cirklar, fyrkant, enskilda, osv. I detta fall använder vi varianten där dom sitter separerat på ett litet runt kretskort som är lätt att sy fast i textil.

Titta du noggrant på en Neopixel så hittar du fyra anslutningar. Plus (+) ska anslutas till 3v (egentligen vill dom ha 5 volt, men den funkar ändå med 3 volt som micro:bit ger). Minus (-) ska anslutas till jord (GND). Sen finns det två pilar, en som går in mot LED-lampan och en som går ut. Dom visar hur data från micro:bit (som berättar vilken färg vi vill se) ska komma in, och sen skickas vidare till nästa LED. Ibland används inte pilar men DI och DO som står för Data In (ingång) och Data Out (utgång).

Koppla ihop

Här ser du hur vi ska koppla ihop hela kretsen. Från jord (GND) går ledande tråd till minus (-) på varje Neopixel. Från ström (3v) går ledande tråd till positiv (+) på varje Neopixel. Från pin 0 till första Neopixel’s ingång. Sen från första Neopixel’s utgång till andra Neopixels ingång.

Den här ritningen är ett förenklat diagram. Såklart kan man hitta på hur lång trådarna ska vara, hur dom ska böja sig, och så vidare.

Sy med ledande tråd

Istället för sladdar, som man ofta ser i kretsar, ska vi använda tråd. Och för att det ska funka som en sladd behöver den leda ström (som en sladd). Därför är denna gjord av stål (det finns olika sorters ledande tråd). När man syr med ledande tråd finns det några tips som är bra att veta om.

  • När man knyter tråden på en elektronisk komponent ska man gå runt flera varv, och dra åt ordentligt, så att det blir en bra kontakt som inte kan flytta på sig.
  • Tråden vill rotera av sig självt, så det kan hjälpa att rotera nålen åt andra hållet för att motverka det medans man syr.
  • Olika trådar ska inte kunna nudda varandra, för då blir det kortslutning. Det betyder att man ska behålla lite rum mellan trådarna, och när dom korsar varandra ska dom sitta på motsatta sidor av textilen. Tänk också på att du kan kortsluta trådar när du vikar textilen.
  • Klipp av alla löst hängande trådändar.
  • Vid en Neopixel ska tråden som går till ingången vara separerat från den som kommer ut från utgången på samma pixel. Det ska inte vara samma tråd.

Mera tips finns på engelska här hos Adafruit.

Skriva kod

Har du fått ihop allting? Då är det dags att programmera vår micro:bit och blåsa liv i lamporna! Gå in på makecode.microbit.org för att starta editorn. Under kugghjulet på höger sidan hittar du knappen ”language” för att byta språk till svenska.

Det första vi behöver göra är att berätta för micro:bit att vi har kopplat Neopixels till den. Och eftersom det inte är en standard komponent på micro:bit, behöver vi lite extra kod för att kunna använda dom. Detta kallas paket, som vi ska lägga till. Tryck på ”Avancerat” och sen längst ner på ”Lägg till paket”. Välj där ”Neopixel”. Då läggs det till en kategori som heter ”Neopixel”.

Nu är vi redo för att säga till micro:bit att den har fått Neopixels kopplat på sig. När vi gör det ska dom få ett namn (alla tillsammans som grupp), så att vi sen kan använda namnet när vi vill göra någonting med dom. Därför går vi in på kategorin Variabler, och trycker på ”Skapa en variabel”. Fyll i vad du vill kalla dina lampor, till exempel lampor. Dra ut ett ”Sätt namnlös på”-block till ”vid start” och byt ut namnlös till din nyskapade variabel lampor. Värdet vi ska spara i denna variabel är en beskrivning av våra Neopixels. Denna hämtar vi som första block från Neopixel kategorin. Fyll i vilken pin du har kopplat dina Neopixels till (0, 1 eller 2) och att vi har 2 stycken. RGB (GRB format) är typen, och det kan vi behålla som det är.

let lampor: neopixel.Strip = null
lampor = neopixel.create(DigitalPin.P0, 2, NeoPixelMode.RGB)

Nu har vi många olika sätt att styra färger som ska visas på LED-lamporna. Den enklaste är att ställa in (och visa) alla till samma färg. Se till att varje gång välja din variabel istället för namnlös. Om man inte gör det förstår micro:bit inte vad den ska göra. Simulatorn (på vänster sidan) kraschar då oftast, och kan behöva att du startar om den med knappen (längst ner).

let lampor: neopixel.Strip = null
lampor = neopixel.create(DigitalPin.P0, 2, NeoPixelMode.RGB)
lampor.showColor(neopixel.colors(NeoPixelColors.Red))

Funkar det?

Ladda ner koden till din micro:bit och testa om dina Neopixels blir röda! Om så inte är fallet får du felsöka. Kolla om alla trådar går som dom ska, om dom gör bra kontakt överallt, och att inga trådar nuddar varandra. Kolla också om du har samma pin vald i din kod som du har sytt Neopixlarna på.

Blink!

Nästa steg är att blinka antingen höger eller vänster lampa för att visa riktningen man ska svänga till. Vad sägs om att använda A och B knappen på micro:bit för det? I kategorin Input drar vi ut ”när knapp A trycks”-blocket. Allt som läggs på insidan av den kommer att köras när vi trycker på A-knappen.

En sak att veta om Neopixels

Nu kommer en liten klurig grej med Neopixels som man borde veta, vilket också ger oss mer kontroll. I en rad av Neopixels kan man ställa in färgen för varje pixel separat. Men att ställa in färgen betyder inte att det visas direkt. Det betyder bara att vi berättar för en pixel: ”Hej du pixeln som sitter på denna plats, jag vill att du ska förbereda dig att byta till denna färg, men vänta tills jag säger NU!”. Och bara när du säger visa (”show” på engelska) kommer det att hända. Det coola med detta är att man kan bestämma färg för alla pixlar steg för steg, och sen få dom alla att byta precis samtidigt. Så efter varje ändring man har gjort och vill visa, ska du lägga till ”show”-blocket. Det som kan vara lite förvirrande är att vissa block har denna ”show” byggt i dom, så att dom visar sina effekter direkt. Du kan se det på att dom har ordet ”show” i blockets namn. Ett exempel är den som vi just använde, ”lampor show color red”.

Nu då, blink!

Med denna nya kunskap kan vi fortsätta bygga vår blinker. Säg att vi vill blinka den första pixeln gult några gånger när vi trycker på A-knappen. (Om det är höger eller vänster beror på hur du har sytt fast den på reflexvästen.) Då drar vi ut ”set pixel color at 0 to red”-blocket och lägger den i knappblocket. Byt till rätt variabelnamn, och välj gul (yellow) som färg. Vad betyder den där 0? Det handlar om vilken pixel vi pratar med. I detta fall är det den första, eftersom man inom programmering vanligtvis börjar räkna med noll. Så om vi skriver en 1handlar det om andra pixeln, osv. Nu har detta block inget ”show” i sig, så vi lägger också till detta block efter det. Testa i simulatorn att klicka på svarta pricken i A-knappen, och se att första LED blir gult!

För att få den att blinka kan vi byta flera gånger mellan gult och röd. Så då är det bara att lägga till samma två block en gång till, men med röd istället. När man vill upprepa någon bit av kod flera gånger är det smidigt att använda sig av en loop. Från den kategori drar vi in ”upprepa 4 gånger”. Dom fyra block för att visa röd och gult kan vi lägga i den, för att upprepa blinkningen många gånger. Du kan självt bestämma hur många gånger det ska hända.

Testa din kod i simulatorn. Blinkar lampan när du klickar på A-knappen? Inte? Eller kanske super snabbt? Ah just ja.. det här händer super himla snabbt! Vi får nog sakta ner det så att vi kan se det. Från Grundläggande kategorin hämtar vi två gånger en ”pausa”-block, som får ligga efter att vi visar gult och efter att vi visar röd. Testa hur lång pausen ska vara för en bra blinkhastighet.

let lampor: neopixel.Strip = null
input.onButtonPressed(Button.A, () => {
 for (let i = 0; i < 10; i++) {
 lampor.setPixelColor(0, neopixel.colors(NeoPixelColors.Yellow))
 lampor.show()
 basic.pause(200)
 lampor.setPixelColor(0, neopixel.colors(NeoPixelColors.Red))
 lampor.show()
 basic.pause(200)
 }
})
lampor = neopixel.create(DigitalPin.P0, 2, NeoPixelMode.RGB)
lampor.showColor(neopixel.colors(NeoPixelColors.Red))

Samma på andra sidan

Nu vill vi få samma men med andra knappen och med andra lampan. Högerklick på ”när knapp A trycks”-blocket, och välj duplicera. Då får vi en kopi på det hela. Byt ut A-knappen för B-knappen. Och ändra pixelns plats från 0 till 1. Yeah! Ladda ner koden till din micro:bit, och din reflexväst med inbyggda blinkers är färdig!

let lampor: neopixel.Strip = null
input.onButtonPressed(Button.A, () => {
 for (let i = 0; i < 10; i++) {
 lampor.setPixelColor(0, neopixel.colors(NeoPixelColors.Yellow))
 lampor.show()
 basic.pause(200)
 lampor.setPixelColor(0, neopixel.colors(NeoPixelColors.Red))
 lampor.show()
 basic.pause(200)
 }
})
input.onButtonPressed(Button.B, () => {
 for (let i = 0; i < 10; i++) {
 lampor.setPixelColor(1, neopixel.colors(NeoPixelColors.Yellow))
 lampor.show()
 basic.pause(200)
 lampor.setPixelColor(1, neopixel.colors(NeoPixelColors.Red))
 lampor.show()
 basic.pause(200)
 }
})
lampor = neopixel.create(DigitalPin.P0, 2, NeoPixelMode.RGB)
lampor.showColor(neopixel.colors(NeoPixelColors.Red))

Länk till koden.

Finns det mer?

Visst finns det mer man kan göra. Neopixels kan ha många olika färger, och man kan animera dom väldigt snyggt. Och micro:bit har en hel del kula funktioner som man skulle kunna utnyttja.

Till exempel..

Kommentera

E-postadressen publiceras inte. Obligatoriska fält är märkta *