Étape 2: Un modèle simple.
la grille
Créer un nœud de la grille avec le paramètre de ligne défini à 56. Il s’agit d’une ligne verticale de notre image. Ensuite, définissez le paramètre de colonnes à 25. Changer les dimensions de celui-ci à largeur 120 et la hauteur 300. Elle se traduira par une grille de points.
Cette grille de points est triée selon l’axe Y. Nous devons changer pour que les 56 premiers points sont la première colonne de la grille, le deuxième groupe de 56 points de la deuxième colonne dans la grille et ainsi de suite.
Créer un nœud de tri et branchez grid1 sur le port de formes. Remplacez le paramètre de commande X.
la forme
La prochaine chose que nous avons besoin est une forme.
Créer un nœud d’ellipse et laisser à ses paramètres par défaut.
le chevauchement
L’idée est que nous allons essayer de comprendre quels points de la grille chevauchent l’ellipse. Ceux qui dois-je être stockées en tant que 1, ceux qui n’ont pas à être stockés comme 0. Ce n’est pas une fonction de construire-dans, mais NodeBox nous permet d’utiliser notre propre code ainsi.
Ouvrez un éditeur de texte et entrez
def cook (forme, points): si shape.contains (points.x, points.y): retourne 1 d’autre : retourne 0Enregistrez-le sous un fichier python appelé check.py. Maintenant que nous avons une fonction à appeler, il peut être implémenté dans NodeBox. Tout d’abord, il faut importer le fichier python dans le programme.
* Allez dans fichier >> bibliothèques de Code. Il ouvrira une nouvelle petite fenêtre avec dans le coin supérieur droite coin un signe « + ».
* Appuyez sur « + » et sélectionnez Python Python / option de fermeture. Accédez à check.py
* Si vous pouvez voir une référence à celui-ci, vous pouvez fermer la fenêtre.
Le fichier python est maintenant importé et la fonction qu’il peut être appelée pour partir d’un nœud.
Chaque nœud réclame une fonction, vous pouvez savoir que l'on en sélectionnant un nœud et ensuite allez dans l’onglet métadonnées sur le dessus de la fenêtre de paramètres/port. Il va ouvrir une nouvelle fenêtre avec les spécifications du nœud et de ses ports. Si vous allez dans « Paramètres », vous pouvez savoir quelle fonction il veut dire. Dans le cas d’un rectangle, il dira : corevector/rect, ce qui signifie qu’il appellera la fonction rect dans le fichier corevector. Pour appeler la fonction de cuisson en checkImage.py, je vais devoir appeler checkImage/cuisinier.
J’ai besoin d’un nœud où je peux envoyer une forme et une liste de points et qui retourne une liste (de 0 à 1). Nous pouvons utiliser le nœud de filtre d’abord car elle importe déjà une forme.
* Créer un nœud de filtre.
* Sélectionnez le nœud et allez dans l’onglet métadonnées.
* Accédez au nœud >> Settings. Entrez « cocher/cuisson » dans l’option « Fonction ».
Nous avons encore besoin d’un nouveau port. Pour l’instant, le nœud ne peut recevoir une forme.
* Dans la fenêtre de métadonnées : cliquez sur le bouton « + » sur le coin inférieur gauche.
* Entrez un nom de port : appelez-le « points ».
* Sélectionnez « pointer » dans le menu Type, puis appuyez sur « OK ».
Maintenant nous avons deux ports d’entrée, un noir pour notre forme (l’ellipse) et un bleu pour nos points (pour notre grille trié).
Branchez sort1 jusqu’au port de points du nouveau nœud de filtre et ellipse1 sur le port de la forme du nœud de filtre. Il doit retourner une liste des 0 et des 1 que nous pouvons utiliser pour créer une couleur.
il visualise
Créer un nœud de couleur RVB et modifier la plage à 1. Connectez filter1 à la voie verte. Maintenant, nous pouvons visualiser en NodeBox ce qui sera plus tard sur l’interface.
* Créer un nœud rect 5 par 5.
Créer d’un nœud Traduisez et connecter le rect à son paramètre de forme et sort1 à son paramètre de traduire.
Créer d’un nœud colorise et connecter se traduisent par elle. Connecter le nœud de rob pour le paramètre de remplissage de cette colorise le nœud et de le rendre. L’ellipse doit apparaître. (voir la capture d’écran sur le dessus de cette étape)
dans l’hexagone.
Première étape consiste à créer des paires de 8, puis de les écrire en valeur hexadécimale et puis elle sortie vers un fichier.
* Créer un nœud de tranche. Réglez le paramètre amount sur 8 et reliez filter1 vers le port de la liste. L’index de début nous permettra de lire les 8 valeurs et nous voulons le faire au cours d’une étape de 8. Créer un sous-réseau pour elle et nommez-le eight_bit. Publier le paramètre d’index de début est accessible depuis la racine.
Créer d’un nœud count, raccordez filter1 à sa liste port. Cela affiche le nombre de valeurs dans la liste.
Créer un nœud de la gamme et connecter le comte il est port de fin. Définissez le paramètre de l’étape 8. Cette propriété renvoie une liste 0, 8, 16, 24, 32,... Nous pouvons utiliser ces valeurs comme l’index de début de notre noeud eightbit. Raccordez-le.
* Allez dans le sous-réseau et créer 8 nœuds de tranche. Chacun d’eux a 1 comme paramètre amount. Le premier a start index 0, la seconde 1... Connectez-les tous vers le premier nœud de la tranche (avec la quantité de 8).
* Créer 3 nœuds CONCATENER. Tous les nœuds de tranche (avec montant 1) y connecter et voir les résultats comme 00000000 00000000 00000000, 00011111...
Ouvrez un éditeur de texte et entrez
importation mathdef tohex(n) : hex(int(n,2)) de retour
Enregistrez-la sous tohex.py
Importez-le dans NodeBox en utilisant l’option bibliothèques de code.
Créez un nouveau noeud est un noeud de base pour être étendu pour les nœuds personnalisés. Allez dans les métadonnées et changer sa fonction à « tohex/tohex ». Créer un nouveau port, appel il peu et placer le type de chaîne.
Le nœud de huit bits y connecter et de le rendre. Le résultat devrait être les valeurs hexadécimales 0 x 0, 0 x 3, 0xff...
Il est important de savoir combien de « paquets de huit » il sont alors créer un nouveau nœud de comte. Connectez le nœud hexagonale à son paramètre de liste.
pour arduino
Maintenant nous allons imprimer dans un fichier. Nous allons utiliser un format csv.
Ouvrez un éditeur de texte et entrez :
import csvdef writetocsv(hexes,name) : liste =]
csvfile = fichier ('/ Users/Desktop /'+ nom + '.csv', 'w') # cela devrait se référer à un dossier sur votre ordinateur
auteur = csv.writer (csvfile, délimiteur = «, »)
pour hex en hexagones : list.append(hex) writer.writerow(list)
csvfile.Close()
hexagones de retour
Enregistrez-le sous toarduino.py. Créez un nouveau noeud de base à nouveau, changer sa fonction à « toarduino/writetocsv » et créer deux nouveaux paramètres. Les deux ont un widget de la chaîne mais le premier a une liste comme gamme, tandis que le second a valeur comme gamme. Appel le premierà maléfices et le second un nom. Nous envoyer la sortie du nœud hexagonale dans le port de maléfices et entrez un nom de fichier dans le paramètre name.
code de l’Arduino
Voici le code arduino commencé de tutoriel de Tom Igoe sur l’aire de jeu pour Arduino. La fonction shifter traverse tous les octets et a 3 arguments. (tableau de séquence, temporisé, montant). ovale octet [175] stocke les informations de NodeBox.
Le potPin réfère à un potentiomètre qui permet nous pour contrôler la temporisé sur l’interface.
--
//**************************************************************//
code a commencé à partir de cet exemple d’aire de jeu pour arduino :
Nom : shiftOutCode, Hello World
Auteur : Carlyn Maw, Tom Igoe, David A. Mellis
Date : 25 octobre 2006
Mis à jour le : 23 mars 2010
Version : 2.0
Note : Le Code pour l’utilisation d’un registre à décalage 74HC595 / /
: à compter de 0 à 255
//****************************************************************
int latchPin = 8 ;
int clockPin = 12 ;
int potPin = A0 ;
int dataPin = 11 ;
ovale octet [175] = {0 x 0, 0 x 0, 0 x 0, 0 x 0, 0 x 0, 0 x 0, 0 x 0, 0 x 0, 0 x 0, 0 x 0, 0 x 0, 0 x 0, 0 x 0, 0 x 0, 0 x 0, 0 x 0, 0 x 0,
0 x 0 0 x 0, 0 x 0, 0 x 0, 0 x 0, 0 x 0, 0 x 0, 0xff, 0 x 0 0 x 0, 0 x 0, 0 x 0, 0 x 0, 0 x 3, 0xff, 0xc0, 0 x 0 0 x 0, 0 x 0, 0 x 0, 0 x 7,
0xFF, 0xe0, 0 x 0, 0 x 0, 0 x 0, 0 x 7, 0 x 0, 0xff, 0xe0, 0 x 0, 0 x 0, 0 x 0, 0 x 0, 0xf, 0xff, 0xf0, 0 x 0 0 x 0, 0 x 0, 0 x 0, 0xf,
0xFF, 0xf0, 0 x 0 0 x 0, 0 x 0, 0 x 0, 0x1f, 0xff, 0xf8, 0 x 0 0 x 0, 0 x 0, 0 x 0, 0x1f, 0xff, 0xf8, 0 x 0 0 x 0, 0 x 0, 0 x 0, 0x1f,
0xFF, 0xf8, 0 x 0 0 x 0, 0 x 0, 0 x 0, 0x1f, 0xff, 0xf8, 0 x 0 0 x 0, 0 x 0, 0 x 0, 0x1f, 0xff, 0xf8, 0 x 0 0 x 0, 0 x 0, 0 x 0, 0x1f,
0xFF, 0xf8, 0 x 0 0 x 0, 0 x 0, 0 x 0, 0x1f, 0xff, 0xf8, 0 x 0, 0 x 0, 0 x 0, 0 x 0, 0xf, 0xff, 0xf0, 0 x 0 0 x 0, 0 x 0, 0 x 0, 0xf,
0xFF, 0xf0, 0 x 0, 0 x 0, 0 x 0, 0 x 7, 0 x 0, 0xff, 0xe0, 0 x 0, 0 x 0, 0 x 0, 0 x 7, 0 x 0, 0xff, 0xe0, 0 x 0 0 x 0, 0 x 0, 0 x 0, 0 x 3,
0xFF, 0xc0, 0 x 0, 0 x 0, 0 x 0, 0 x 0, 0 x 0, 0xff, 0 x 0 0 x 0, 0 x 0, 0 x 0, 0 x 0, 0 x 0, 0 x 0, 0 x 0, 0 x 0, 0 x 0, 0 x 0, 0 x 0, 0 x 0,
0 x 0 0 x 0, 0 x 0, 0 x 0, 0 x 0, 0 x 0, 0 x 0, 0 x 0, 0 x 0, 0 x 0, 0 x 0} ;
void setup()
{
pinMode (dataPin, sortie) ;
pinMode (latchPin, sortie) ;
pinMode (clockPin, sortie) ;
pinMode (potPin, entrée) ;
Serial.Begin(9600) ;
}
Sub shifter (seq1 Byte, flotteur temporisé, int len) {}
pour (int x = 0; x < len; x ++)
{
digitalWrite (latchPin, basse) ; commencer sturen via latchpin
Si (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, HIGH) ; arrêter versturen
Delay(timeDelay) ;
}
Delay(timeDelay*20) ;
}
void loop() {}
temp de flotteur = analogRead(potPin) ;
flotteur timeDelay = mappé (temp, 0, 1023, 0, 25) ;
levier de vitesses (ovale, temporisé, 175) ;
}
flotteur mappé (float x, float in_min, float in_max, float out_min, float out_max) {}
retour (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min ;
}
une autre image
Maintenant nous avons un modèle de base que nous pouvons utiliser pour créer d’autres images. Changement de l’ellipse à une autre forme crée un nouveau tableau. Vous pouvez créer un seul caractère d’un alphabet. etc.
