LED-matris på en budget (4 / 5 steg)

Steg 4: programvara

Val...

När det gäller programvara har du flera alternativ, kan du antingen:

1. köra matrisen som en fristående enhet
2. Använd din PC för att driva bilder/animationer till matrisen
3. eller komma med din egen idé (e.g ansluta det till en esp8266 att visa innehållet på internet

I. fristående

bara leka med den FastLED biblioteken för Arduino-plattformen. Det finns massor av goda exempel online, som du hittar här i mappen exempel. Du kan behöva ändra några rader i skisserna, som:

1. vilken typ av LED du använder (bara ändra det till "WS2812").
2. beloppet av din matris består av lysdioder.

II. kontroll matrisen via PC

Detta är det sätt som jag föredrar att göra det. GreatScott gjorde nyligen en bra handledning om hur du använder programvaran glediator. Han kom också med en skiss (en Arduino program) som fungerat bra för mig.

Men jag ville skriva min egen kod och kom upp med detta python-skript. Bara se till att du har valt rätt com-port i linje 95 och köra dessa på datorn med din matris ansluten till den. Det (script) fungerar också alldeles utmärkt med Greatscott's glediator skiss, så du slipper du reprogramm din Arduino. Observera att jag bara testat dem med Debian Linux, men det inte bör vara alltför komplicerat att få dem att fungera under Windows eller OSX. Känn dig fri att kopiera och ändra koden för att passa dina behov. Om du har några frågor angående koden, som är lite kryptiska, Välkommen att fråga i kommentarerna nedan. Se också till att kolla in nästa sida, där jag kör Conway's Game of Life på matrisen.

Men exakt hur är allt detta arbetssätt?

Lysdioderna används i detta projekt innehåller SKIFT-register, vilket är i princip små kretsar som kan innehålla en liten mängd data (i form av ettor och nollor). I denna ansökan data som lagras i varje led SKIFT register representerar dess färg och består av 24 bitar (8 bitar per färg). Den fasta programvaran körs på Arduino tar emot data via seriell kommunikation och sedan skiftar det genom seriekoppling av SKIFT register/lysdioder. Arduinoen själv behandlar matrisen som om det var en normal LED rand (1-dimensionell). Mitt manus nedan beräknas varje pixlar färger (RGB) och lagrar den i en 2-dimensionell array, vilket i princip motsvarar matrisen själv. Efter beräkning av varje pixel RGB-värden (varje representeras av ett värde mellan 0 och 255 [2⁸]) fortsätter det sedan genom att trycka dessa värden till Arduino via en seriell port på datorn. Detta händer på en viss ordning, eftersom Arduino skränande adress LEDs i ett cartesian slag av väg (x, y). Data skjuts med en viss hastighet av bilder per sekund, vilket leder till en illusion av ett flytta/blekning mönster på matrisen.

#-*-kodning: utf-8-*-

importera kopia
Importera tid
importera följetong < /p >< p > bredd = 6
HÖJD = 10
PIXLAR = BREDD * HÖJD
FPS = 120.0

#--RGB--objekt
klass RGB:
def __init__(self,red,green,blue):
Self.r=Red
Self.g=Green
Self.b=Blue
def setcolor(self,red,green,blue):
Self.r=Red
Self.g=Green
Self.b=Blue

#--skapa--matris
def new_m(w,h): #width/höjd / / returnerar 2 dimensionell lista
Matrix =]
rad =]
x i xrange(w):
Row.append(RGB(0,0,0))

för y i xrange(h):
Matrix.append(copy.deepcopy(Row))

returnera matrisen

#--Tryck - matris
def print_m (m): #matrix / / 2 dimensionell lista
h=len(m)
w=len(m[0])
för y i xrange(h):
Skriv ut y,"> |",
x i xrange(w):
Skriv ut x,"", m [y] [x] Rosencrantz, m [y] [x] t.ex, m [y] [x] spelar, "|",
Skriv ut""

def img_to_m(path,m): #path / / matrix / / bredd / / höjd
Jag = Image.open(path)
pixlar = i.load() < /p >< p > h=len(m)
w=len(m[0])

x i range(w):
för y i range(h):
m [y] [x] Rosencrantz, m [y] [x] t.ex, m [y] [x] spelar = pixlar [x, y]

def send_serial(ttyobj,m): #n = antal der pixel,m=matrix(liste) / / n = mängden pixlar, m = matrix (lista)
h=len(m)
w=len(m[0])
ttyobj.write(Chr(1)) #eine 1 pro antal aller pixel (hier 60) / / glediator protokoll
x i xrange(w): #layout der pixel: erst spalten, dann zeilen von oben rechts beginnend / / första rader och kolumner, start i det övre högra hörnet...
för y i xrange(h):

TTY.write(Chr(m[y][w-1-x].r))
TTY.write(Chr(m[y][w-1-x].g))
TTY.write(Chr(m[y][w-1-x].b))

def calc(f,m): #frame, matrix
h=len(m)
w=len(m[0])
samtidigt f > 255:
f=(f-255)
för y i xrange(h): #alle pixel durchgehen / / gå igenom alla pixlar
x i xrange(w):
m[y][x].SetColor(255-f,f,255)
returnera m #returns bearbetade bilden

#MAINLOOP

kör = sant
ram = 0
target_delta = 1/FPS

skriva ut "skapa matrix..."
Matrix=new_m(width,height)

skriva ut "öppna serieporten..."
TTY = följetong. Serial("/dev/ttyACM3", 500000) #EDIT till COMX
Time.Sleep(1)

medan du kör:
time_a=Time.Time()
Matrix=calc(Frame,Matrix)
#print ram
time_b=Time.Time()
Time.Sleep(target_delta-(time_b-time_a))

send_serial(TTY,Matrix)
skriva ut 1/(time.time()-time_a)
RAM = RAM + 1 < /p >