Att skapa POV sekvenser. (2 / 4 steg)

Steg 2: En enkel mall.

Nodebox är ett bra verktyg för att visualisera saker. Låt oss börja med ett enkelt exempel som visualiserar en ellips i gränssnittet. Nyckeln är att vi har 56 LED'S. Nedan är en beskrivning av ett enkelt exempel men det kan vara lättare att ladda ner den baseReader.zip som ingår och öppna den i Nodebox så att du kan se det steg för steg...

rutnätet

Skapa en grid nod med parametern rad-56. Detta blir en lodrät linje av vår image. Nästa ange parametern kolumner till 25. Ändra måtten för det bredd 120 och höjd 300. Det kommer att resultera i ett raster av punkter.

Rutnätet poäng sorteras på Y-axeln. Vi måste ändra det så att de första 56 poäng är den första kolumnen i rutnätet, andra uppsättningen av 56 punkter den andra kolumnen i rutnätet och så vidare.

Skapa en slags nod och Anslut grid1 till formerna-porten. Ändra orderparametern till X.

formen

Nästa sak vi behöver är en form.
Skapa en ellips nod och lämna den på det förvalda parametrar.

överlappningen

Tanken är att vi kommer att försöka lista ut vilka punkter i rutnätet överlappar ellipsen. De som har kan lagras som 1, de som behöver inte lagras som 0. Detta är inte en inbyggd funktion, men NodeBox tillåter oss att använda vår egen kod.

Öppna en texteditor och ange

^{def cook (form, poäng): om shape.contains (points.x, points.y): returnera 1 annars: returnera 0}

spara den som en python fil som heter check.py. Nu när vi har en funktion att ringa för, kan det genomföras i NodeBox. Först måste vi importera filen python i programmet.

* Gå till Arkiv >> kod bibliotek. Det kommer att öppna ett nytt litet fönster med i övre höger hörn ett "+" tecken.
* Tryck på "+" och välj Python Python / stängning alternativet. Bläddra till check.py
* Om du kan se en hänvisning till den kan du stänga fönstret.

Python-fil importeras nu och funktionen i det kan kallas för från en nod.

Varje nod efterlyser en funktion, kan du veta vilken genom att välja en nod och gå sedan till fliken metadata på toppen av fönstret port/parametrar. Det kommer att öppna ett nytt fönster med specifikationer för noden och dess hamnar. Om du går till hänvisar 'Inställningar' hittar du vad fungera den till. När det gäller en rektangel kommer det att säga: corevector/rekt, vilket innebär att det kommer att anropa funktionen rect i filen corevector. Att anropa funktionen cook i checkImage.py jag kommer att behöva ringa checkImage/kock.

Jag behöver en nod där jag kan skicka en form och en lista med punkter att och som returnerar en lista (av 0 och 1). Vi kan använda noden filter till att börja med eftersom det redan importerar en form.

* Skapa en filter-nod.
* Markera noden och gå till fliken Metadata.
* Gå till noden >> Inställningar. Ange "check/kock" i alternativet "Funktion".

Vi behöver fortfarande en ny port. Noden för tillfället bara kan ta emot en form.

* I fönstret Metadata: Klicka på "+" knappen i nedre vänstra hörnet.
* Ange ett portnamn: kalla det "punkter".
* Välj "pekar" menyn och tryck på "OK".

Nu har vi två ingående portar, en svart en för vår form (ellips) och en blå för våra poäng (för våra sorterade rutnät).

Anslut sort1 till poäng-porten till den nya noden filter och Anslut ellipse1 till formen port noden filter. Den borde returnera en lista över 0 och 1 som vi kan använda för att skapa en färg.

visualisera det

Skapa en rgb färg nod och ändra det till 1. Anslut filter1 till den gröna porten. Nu kan vi visualisera i NodeBox vad blir på gränssnittet senare.

* Skapa en rect nod av 5 av 5.
* Skapa en Översätt nod och Anslut rekt att det är formen parameter och sort1 att det är Översätt parameter.
* Skapa en colorise nod och Anslut översätta till det. Ansluta noden rob till parametern fylla detta colorise nod och göra den. Ellipsen ska visas. (se skärmdump över detta steg)

i hex.

Första steget är att skapa par av 8, sedan för att skriva dem i hexadecimalt värde och sedan ut det till en fil.

* Skapa en slice nod. Anger parametern belopp till 8 och Anslut filter1 till listan port. Start index ger oss möjlighet att läsa 8 värden och vi vill göra det över ett steg 8. Skapa ett undernätverk för det och kalla det eight_bit. Publicera parametern start index så är tillgänglig från roten.

* Skapa en greve nod, ansluta filter1 till dess listan port. Detta resultat antalet värden i listan.
Skapa en rad nod och Anslut räkna att det är slutet port. Ange parametern steg till 8. Detta returnerar en lista 0, 8, 16, 24, 32,... Vi kan använda dessa värden som start index av våra eightbit nod. Ansluta den.

* Gå i delnätverk och skapa 8 bit noder. Var och en av dem har 1 som beloppet parameter. Den första har start index 0, den andra en 1... Ansluta dem alla till noden första skiva (med mängden 8).

* Skapa 3 sammanfoga noder. Anslut alla segment noder (med belopp 1) till dem och se resultat som 00000000 00000000 00000000, 00011111...

Öppna en texteditor och ange

^{import matematik
def tohex(n): tillbaka hex(int(n,2))}

spara den som tohex.py

importera den till NodeBox med hjälp av koden bibliotek alternativet.

Skapa en ny nod som är en bas nod utvidgas för anpassade noder. Gå till metadata och ändra den funktionen till "tohex/tohex". Skapa en ny port, kalla det lite och sätta typen sträng.
Ansluta åtta bitars noden till den och göra den. Resultatet bör hex värden som 0x0, 0x3, 0xff...

Det är viktigt att veta hur många "paket av åtta" det är så skapa en ny räkning nod. Ansluta den till hex nod till det är parametern lista.

till arduino

Nu låt oss utdata till en fil. Låt oss använda en CSV-format.

Öppna en texteditor och ange:

^{import csv
def writetocsv(hexes,name): lista =]
csvfile = fil ("/ användare/Desktop /" + namn + ".csv', 'w') # Detta bör hänvisa till en mapp på din dator
författare = csv.writer (csvfile, avgränsare = ",")
för hex i hexes: list.append(hex) writer.writerow(list)
csvfile.Close()
returnera hexes}

spara det som toarduino.py. Skapa en ny bas nod igen, ändra den funktionen till "toarduino/writetocsv" och skapa två nya parametrar. Båda har en sträng widget men den första har en lista som intervall, medan den andra har värde som intervall. Ring först hexes och det andra en namnet. Vi kommer att skicka utdata till hex noden till hexes porten och ange ett filnamn i Namnparametern.

Arduino kod

nedan är den arduino koden startade från Tom Igoe tutorial på Arduino playground. Funktionen shifter går genom alla byte och har 3 argument. (sekvens matris, timedelay, belopp). byte oval [175] lagrar information från NodeBox.
PotPin avser en potentiometer som gör oss för att styra timedelay på gränssnittet.

--

//**************************************************************//
kod från exemplet arduino playground:
Namn: shiftOutCode, Hej världen
Författare: Mervi Maw, Tom Igoe, David A. Mellis
Datum: 25 okt 2006
Ändrad: 23 Mar 2010
Version: 2.0
Anteckningar: Kod för att använda en 74HC595 SKIFT Register / /
: att räkna från 0 till 255
//****************************************************************

int latchPin = 8;
int clockPin = 12;
int potPin = A0;
int dataPin = 11;

byte oval [175] = {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0xff, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x7,
0xFF, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xf,
0xFF, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x1f,
0xFF, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x1f,
0xFF, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x1f, 0xff, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xf, 0xff, 0xf0, 0x0, 0x0, 0x0, 0x0, 0xf,
0xFF, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x3,
0xFF, 0xc0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0};

void setup()
{
pinMode (dataPin, produktionen);
pinMode (latchPin, produktionen);
pinMode (clockPin, produktionen);
pinMode (potPin, ingång);
Serial.BEGIN(9600);
}

void shifter (byte seq1 [], float timeDelay, int len) {
för (int x = 0; x < len; x ++)
{
digitalWrite (latchPin, låg); Starta sturen via latchpin
om (x %7 == 0) {
shiftOut (dataPin, clockPin, MSBFIRST, seq1[x]);
shiftOut (dataPin, clockPin, MSBFIRST, seq1[x+1]);
shiftOut (dataPin, clockPin, MSBFIRST, seq1[x+2]);
shiftOut (dataPin, clockPin, MSBFIRST, seq1[x+3]);
shiftOut (dataPin, clockPin, MSBFIRST, seq1[x+4]);
shiftOut (dataPin, clockPin, MSBFIRST, seq1[x+5]);
shiftOut (dataPin, clockPin, MSBFIRST, seq1[x+6]);
shiftOut (dataPin, clockPin, MSBFIRST, seq1[x+7]);
}
digitalWrite (latchPin, hög); stoppa versturen
Delay(timeDelay);
}
Delay(timeDelay*20);
}

void loop() {
float temp = analogRead(potPin);
flyta timeDelay = mappas (temp, 0, 1023, 0, 25);

Shifter (oval, timeDelay, 175);
}

float mappas (float x, float in_min, flyta in_max, flyta out_min, flyta out_max) {
RETUR (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}

en annan bild

Nu har vi en grundläggande mall som kan användas för att skapa andra bilder. Ändra en ellips till en annan form skapar en ny matris. Du kan skapa ett enstaka tecken i ett alfabet. etc.