Affichage POV Digilog_Bike : 14 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:06

Digilog

Numérique + Analogique

Le numérique rencontre l'analogique

Point de vue

Persistance du visuel

Également connu sous le nom d'affichage d'image rémanente, s'il est secoué à grande vitesse, l'image rémanente reste.

Les gens pensent qu'ils regardent une vidéo lorsqu'ils regardent la télévision. Mais en fait, il regarde plusieurs photos consécutives. Ceci est confondu avec une image en raison de l'effet des images rémanentes restant sur nos rétines lors de la visualisation d'images successives. Ce genre d'illusion s'appelle un POV.

Étape 1: Idée Concept

Le POV est mis en œuvre en attachant une sangle LED à la roue d'un vélo.

Étape 2: Liste des matériaux

Informatique & E/S

1. Arduino Mega 2560 [arduino] x3

2. Module de capteur à effet Hall V2 [YwRobot] x3

3. WS2812-5050 Néopixel flexible [Adafruit] x3

4. Magnétique (diamètre de 15 mm, épaisseur de 50 mm) x3

5. Arduino Mega Case x3

Ligne électrique

5. Batterie au lithium 5000mAh/3.7V [TheHan] x3

6. Régulateur AVR 5V et module de charge et PCM: JBATT-U5-LC [Jcnet] x3

7. Kit de 4 fils de cavalier 65PCS/SET [OR0012] x3

Étape 3: Outils

Pas trop d'outils nécessaires mais il vous faudra:

1. Machine à souder

2. Un fer à souder

3. Pistolet à colle

4. Pince

Étape 4: Faire le cadre

Découpe du vélo et fixation de la base

La meuleuse a été utilisée pour couper les roues du vélo et des plaques d'acier soudées pour fixer les roues.

Étape 5: Esquisse des images et des concepts finaux

Nous avons choisi un dragon comme image finale. Parce que la vague du dragon semblait être mieux représentée par l'effet d'image rémanente.

Étape 6: Faire couper l'image en mouvement

Divisez l'image en trois parties qui s'adapteront à chaque vélo et divisez le total de 12 images par couleur et mouvement.

Étape 7: Préparation du logiciel

Sous-partie 1. Installer Arduino

Téléchargement Arduino:

(Installez pour s'adapter à la version de votre système d'exploitation et à votre système.)

-

Sous-partie 2. Installer la bibliothèque

*(Si vous souhaitez installer via Github, veuillez visiter le lien ci-dessus Github Arduino Library:

1. Exécutez le programme Arduino

2. Autoriser le lien Menu supérieur – croquis – inclure la bibliothèque – ajouter la bibliothèque. Zip

3. Vous devez choisir le fichier. Zip qui a déjà installé la bibliothèque github4

*(Si vous souhaitez utiliser les services du programme Arduino)

1. Exécutez les programmes Arduino

2. Autorisez le lien Menu supérieur - croquis - bibliothèque d'inclusion - bibliothèque de gestion - recherche "Adafruit neopixel" - vous pouvez voir "Adafruit Neopixel par Adafruit"

3. Installer et mettre à jour la bibliothèque

-

Sous-partie 3. Installer le programme de conversion

1. Installez le programme Rotation Circle (R. C. P):

2. Vous devez lire un fichier README

Étape 8: Création d'une alimentation matérielle

* Voici comment fournir une tension Arduino 5V via la batterie. Veuillez suivre les étapes ci-dessous.

1. Connectez la batterie au lithium et le module de charge JBATT. (Pour référence, le module JBATT a un interrupteur d'alimentation intégré.)

2. Connectez la borne de sortie de JBATT à la borne Vin d'Arduino et à la borne de terre.

3. Connectez le port USB Micro 5 broches au port de charge pour vérifier si le produit fonctionne correctement.

4. Ensuite, mettez l'interrupteur intégré sur ON.

5. Si le voyant rouge s'allume et que le voyant vert s'allume dans Arduino, la configuration de l'étage d'alimentation du produit est terminée normalement.

Étape 9: création d'E/S matérielles et vérification de la SORTIE (fonctionnement de NeoPixel)

*Cette partie se compose d'un capteur et d'un étage de sortie

1. Connectez les capteurs Arduino et Hall. La broche de données se connecte à la broche Arduino 2.

2. Lorsque l'Arduino est sous tension et que l'aimant est en contact étroit avec le capteur Hall, la LED rouge s'allume.

3. Connectez Arduino et Neopixel. Seuls 30 Neopixels sont utilisés.

4. Connectez la broche de données avec la broche Arduino 6.

5. Connectez l'Arduino et le câble de téléchargement au port USB de votre ordinateur et exécutez Arduino sur votre ordinateur.

6. Sélectionnez Tool - board - "Arduino / Genuino Mega ou Mega 2560" dans la barre de menu supérieure du programme Arduino.

7. Vérifiez s'il existe une liste de produits pouvant être directement connectés au port. S'il n'est pas coché, cliquez pour le sélectionner.

8. Collez le code ci-dessous et cliquez sur Télécharger en haut à gauche. (Ensuite, tous les téléchargements de programmes suivent les étapes 5 à 8.)

9. La configuration est terminée lorsque les 30 pixels neoled s'allument.

#1. y compris le fichier d'en-tête et le prétraitement

Nous devons d'abord apporter la bibliothèque Adafruit_NeoPixel qui est capable d'agir en Neopixels.

La bibliothèque peut être utilisée en déclarant des objets.

La classe Adafruit_NeoPixel peut saisir 3 paramètres en public.

Le premier paramètre est le nombre de LED.

Le paramètre seconds est le numéro de broche connecté à l'entrée numérique Neopixel.

Le troisième paramètre consiste à saisir les options en fonction des caractéristiques du produit. le produit WS2812b tricolore utilise l'entrée 'NEO_GRB'

#comprendre

#define PIN 6 Bande Adafruit_NeoPixel = Adafruit_Neopixel (30, PIN, NEO_GRB+NEO_KHZ800);

#2. mettre en place

Dans la partie configuration, initialisez l'objet et préparez-le à l'utilisation.

'Adafruit_Neopixle_Object.begin()' éteint toutes les LED.

'Adafruit_Neopixle_Object.show()' sort avec la luminosité définie dans la LED.

void setup(){

strip.begin(); strip.show(); }

#3. boucle principale

L'action de la boucle principale utilise une boucle for pour sortir séquentiellement (0,1 seconde) les LED en blanc

boucle vide(){

for(uint16_t i=0;i<strip.numPixels();i++){ strip.setPixelColor(i, 255, 255, 255); strip.show(); retard (100); } }

Étape 10: Assemblage et fixation à la roue

1. Connectez les Neopixels. (Faites attention à la vérification du code PIN)

2. Connectez le capteur à effet Hall. (Reportez-vous à l'étape 9)

3. Fixez le cadre à l'Arduino entre les vélos. (Fixez le boîtier Arduino parallèlement au cadre du vélo).

4. Insérez l'Arduino connecté à Neopixel. (Attention car le pistolet à colle est chaud).

5. Insérez le capteur Hall connecté dans Arduino, (Fixez le serre-câble afin que le capteur Hall ne tombe pas).

6. Souder pour connecter la batterie. (Faites attention lorsque vous soudez).

7. Fixez-le avec un pistolet à colle. (Fixez le module de charge sur la batterie pour sécuriser l'espace).

8. Branchez chaque ligne avant de vous connecter à Arduino, 9. Branchez en fonction de chaque numéro de broche. (Connectez les lignes de saut pour le module de charge sans les confondre).

10. Terminez avec un pistolet à colle une fois, (Veuillez faire attention à ne pas tomber).

Étape 11: Vérification de l'ENTRÉE (données du capteur HALL)

*Vérifiez le code du logiciel pour voir si le capteur fonctionne.

1. Collez et téléchargez le code ci-dessous.

2. Cliquez sur le bouton Serial Monitor en haut à droite de l'Arduino.

3. Lorsque l'aimant est en contact avec le capteur Hall pendant plus d'une seconde, la configuration est terminée lorsque le mot « contact magnétique » apparaît sur le moniteur série.

-------------------------------------------------- -------------------------------------------------- -------------------------------------------------- #1. Définir le numéro de broche et la configuration

Le premier numéro de broche de configuration pour utiliser le capteur Hall et définir le numéro de broche comme port d'entrée uniquement.

Réglez la communication pour vérifier les données du capteur Hall sur le moniteur série.

#définir HALL 2

void setup(){ pinMode(HALL, INPUT); Serial.begin(9600); }

#2. boucle principale

Vérifiez les données du capteur Hall à des intervalles de 0,1 seconde.

Si l'aimant est détecté et que les données sont modifiées, "contact magnétique" est transmis au moniteur série.

boucle vide(){

if(digitalRead(HALL)){ Serial.println("contact magnétique"); } retard (100); }

Étape 12: Algorithme de codage

* Créez une logique et un codage pour contrôler les néopixels en fonction des valeurs du capteur.

1. Collez et téléchargez le code ci-dessous.

2. Il est normal que l'image ne s'affiche pas correctement car aucun cadre n'est généré. Mais vous pouvez voir que cela fonctionne à peu près.

3. Touchez et relâchez rapidement le capteur Hall et l'aimant en 1 seconde. Répétez cette opération environ 10 fois.

4. La configuration est terminée lorsque les couleurs des Neopixels changent régulièrement.

#1. Y compris les fichiers d'en-tête et le prétraitement

Tout d'abord, nous devons comprendre que la mémoire de l'Arduino Mega n'est pas assez grande pour contenir un fichier image.

Par conséquent, le fichier d'en-tête 'avr/pgmspace' est utilisé pour utiliser un espace mémoire différent.

Pour utiliser Neopixels, vous déclarez un objet et configurez un numéro de broche d'E/S.

Le tableau d'images est trop volumineux pour le codage, alors téléchargez et collez les fichiers joints.

#comprendre

#include #define PIN 6 #define NUMPIXELS 30 #define HALL 2 Adafruit_NeoPixel strip = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_RGB + NEO_KHZ800); // coller le tableau dans 'image_array_1.txt' // " 'image_array_2.txt' // " 'image_array_3.txt' // " 'image_array_4.txt'

#2. Variable globale et configuration

Définissez une variable globale.

L'essentiel est de régler la luminosité, cela détermine le cycle de vie du produit.

nombre entier = 0;

double v = 0; double last_v = 0; double minuterie = micros(); double ex_timer = micros(); double last_timer = micros(); int deg = 36; pixel int = 35; int rvb = 3; double q_arr[2] = {0, 0}; int HALL_COUNT = 0; double VELO; double processing_timer = micros(); void setup(){ strip.setBrightness(255); strip.begin(); strip.show(); Serial.begin(230400); }

#3. boucle principale - partie de sortie d'expression d'image

Ce code est une instruction conditionnelle sur la façon d'afficher le temps de rotation de la roue par résolution.

Cette partie utilise le cycle de rotation de la roue de vélo une fois comme un paramètre très important.

En outre, il est important de lire les données de matrice d'images à partir de la mémoire.

boucle vide() {

if ((count (ex_timer / 120,0) - (micros() - processing_timer))) { timer = micros(); if (VELO > 360000) { pour (int i = 0 + 5; i < pix; i++) { strip.setPixelColor(i - 5, strip. Color(pgm_read_byte(&(image_1[count][1])), pgm_read_byte(&(image_1[count][2])), pgm_read_byte(&(image_1[count][0])))); } strip.show(); } else if (VELO 264000) { for (int i = 0 + 5; i < pix; i++) { strip.setPixelColor(i - 5, strip. Color(pgm_read_byte(&(image_2[count][1])), pgm_read_byte(&(image_2[count][2])), pgm_read_byte(&(image_2[count][0])))); } strip.show(); } else if (VELO 204000) { pour (int i = 0 + 5; i < pix; i++) { strip.setPixelColor(i - 5, strip. Color(pgm_read_byte(&(image_3[count][1])), pgm_read_byte(&(image_3[count][2])), pgm_read_byte(&(image_3[count][0])))); } strip.show(); } else if (VELO <= 204000) { for (int i = 0 + 5; i = 120)) { for (int i = 0 + 5; i < pix; i++) { strip.setPixelColor(i - 5, strip. Couleur(0, 0, 0)); } strip.show(); }

#4. boucle principale - contrôle et détection du temps de traitement et de cycle

C'est la partie la plus importante de tout le système.

Tout d'abord, vérifiez le temps nécessaire pour exécuter l'intégralité du code et ajustez le temps de sortie de la LED par cycle.

Le temps détecté à chaque fois que la roue tourne prédit l'heure du prochain cycle.

L'accélération peut être estimée en soustrayant le dernier temps de cycle mesuré du temps de cycle mesuré à temps.

Le système calcule le temps de traitement et l'accélération pour calculer combien de temps les LED s'allument en continu.

processing_timer = micros();

if ((digitalRead(HALL) == HIGH) && (HALL_COUNT == 1)) { VELO = v; v = micros() - last_timer; ex_timer = q_arr[0] - q_arr[1] + v; last_timer = micros(); q_arr[0] = q_arr[1]; q_arr[1] = v; compte = 0; HALL_COUNT = 0; } else if (digitalRead(HALL) == LOW) { HALL_COUNT = 1; } }

Étape 13: Utilisation du logiciel

*Utilisez un logiciel pour transformer l'image et insérer les données de procession dans le code

1. Insérez l'image de l'étape ci-dessus dans le dossier d'images du dossier R. C. P installé à l'étape de préparation.

- Comment mettre l'image est la suivante.- Renommer 4 images animées du produit # 1 dans l'ordre de 1.png, 2.png, 3-p.webp

2. Exécutez le fichier Ver.5.exe.

3. Vérifiez que 12 fichiers pro_1_code_1.txt à pro_3_code_4.txt sont créés dans le dossier R. C. P.

4. S'il n'est pas créé, modifiez le contenu de config.txt en tant que fichier de configuration suivant.

5. Une fois le fichier créé, copiez l'intégralité du contenu du fichier pro_1_code_1.txt et collez-le dans la partie indiquée dans le code ci-dessous.

6. Ajoutez le contenu pro_1_code_2.txt, pro_1_code_3.txt et pro_1_code_4.txt à la partie marquée dans le 5ème ordre.

7. En référence aux 5 et 6, le pro_2_code…, pro_3_code complète le code de la même manière.

Étape 14: Terminer

Achèvement de la production d'un POV qui crée une image avec trois roues.