–
Mise à jour le 25/04/2018 : Le robot Maya ; Ce projet demande de la persévérance , entre les problèmes materiel , logiciel etc… la route est longue mais comme la très bien formulé Samuel Johnson ,ce n’est pas la force, mais la persévérance, qui fait les grandes œuvres.La suite de l’étude dans cette page intitulée « Etude du robot Maya suite «
Mise à jour le 29/12/2019 : Présentation du kit robot mobile HCR DFRobot est une base Mobile de robot à deux roues motrices, comprenant trois niveaux .
Arduino Uno Rev3
Mise à jour le 03/04/2019 .Dans cet article vous trouverez les caractéristiques principales de la carte Teensy 3.2 , ainsi que les cartes additives de différents constructeurs pour son utilisation .
Manipulation Audio et Effets Visuels avec Processing
Mise à jour le 09/01/2024 : Ce code Processing est une démonstration de l’intégration de la bibliothèque audio Minim, utilisée pour créer une visualisation interactive basée sur les entrées audio. Ce projet illustre la transformation des signaux sonores en éléments visuels dynamiques dans l’environnement de programmation Processing
Sommaire :
Présentation de la fonction |
Le logiciel de création multimédia Processing, permet de dessiner et réaliser des animations en deux et trois dimensions , il peut aussi créer des œuvres sonores et visuelles. Concevoir un programme qui permet d’interagir avec l’environnement devient très intéressant pour les personnes qui travaillent sur la robotique ou la domotique. Incorporez la notion de son dans un programme nous ouvre une autre dimension, une interactivité sans précédent, imaginez parler à votre écran et qu’une image informatique vous réponde en bougeant les lèvres là, ça devient beaucoup plus séduisant et beaucoup plus excitant. Dans cette rubrique nous allons voir comment récupérer le son, utilisez le son pour générer cette interactivité.
Pour ajouter une source sonore à notre programme il nous faut pour cela exploiter l’entrée microphone et ou la sortie sonore, nous allons donc utiliser la librairie Minim qui nous permet de rentrer dans cette nouvelle dimension.
Cette rubrique par ses tutoriels et ses exemples vont, je l’espère briser tous les tabous.
Configuration de la fonction Minim |
Lancer votre programme via le bouton Run ne suffit pas pour jouer un son avec Minim. Avant de pouvoir jouer un son, vous devez activer les fonctionnalités de gestion audio de Minim, son moteur audio. Minim doit demander un accès à la carte son de votre ordinateur pour traiter le son. Heureusement, Minim gère cette configuration interne automatiquement. Il suffit simplement d’initialiser Minim dans votre code pour qu’il soit opérationnel. Cependant, il est important de noter que si vous activez Minim, vous devez aussi prévoir de le désactiver à la fin de votre programme pour libérer les ressources audio et éviter les fuites de mémoire.
.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 |
// // // Version de IDE:Processing 3.3.4 // RedOhm // H-Mazelin 25/12/2019 // instruction minimale pour le bon fonctionnement de la // bibliothéque son // Minim est une bibliothèque audio qui permet la manipulation // du son dans l’environnement Processing. import ddf.minim.*; // Création d'une variable qui contiendra le moteur Minim Minim minim; // La fonction setup () est exécutée une fois, lorsque le programme démarre. // Il sert à définir les propriétés d'environnement initiales telle que la // taille de l'écran et à charger des supports tels que des images et/ou des polices // au démarrage du programme. void setup() { // this entre parenthése dans ce code, sachez qu'il sert à indiquer à Processing // que vos instructions s'appliquent à ce programme. // l'instruction Minim a besoin de connaître l'adresse de votre programme pour le // faire communiquer avec la carte son de notre ordinateur minim = new Minim(this); } //Le programme principal s’exécute par une boucle infinie appelée draw () void draw () { } // ***************Procedure d'arret ************************ // il faut prévoir d'arréter la capture du son ainsi que la librairie // minim a la fin de l'execution du programme void stop() { minim.stop(); super.stop(); } |
.
Retour au sommaire
Utilisation de la valeur dans la gestion des formes |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
// Partie du programme traitant des formes // // // ********** utilisation des parametres audio ******************* // pour activer la courbe de bezier // Affichage d'un texte à l'écran // text (texte,x,y); // x => coordonnée x du texte // y => coordonnée y du texte text("Affectation de la valeur audio " , 500,500); text("aux paramétres de la courbe de " , 500,520); text(" Bezier " , 500,540); // Pour dessiner une courbe de bézier, il faut définir quatre // points avec chaque fois 2 valeurs (x,y) . La première et la // dernière définiront le début et le fin de la courbe. Les deux // points intermédiaires définiront les contrôles de courbe // // bezier (ax,ay,c1x,c1y,c2x,c2y,bx,by) // ax,ay => définition du début de la courbe // c1x,c1y => premier contrôle de courbure // c2x,c2y => deuxième contrôle de courbure // bx,by => définition de la fin de la courbe bezier(500,600,550,600-son1,600,600-son1,650,600); bezier(500,600,550,600+son2,600,600+son2,650,600); } |
Tutoriel vidéo |
.
Le programme commence par intégrer la bibliothèque Minim, un outil puissant pour la manipulation du son dans Processing. Une fois la bibliothèque importée, le code initialise Minim et configure une connexion d’entrée audio, permettant ainsi au programme de recevoir des données sonores en temps réel.
Le cœur du sketch repose sur la capture des niveaux sonores à travers l’objet AudioInput, représenté par la variable in. Cette entrée sonore est ensuite analysée et transformée en plusieurs variables à virgule flottante (son, son1, son2, son3, son4). Chacune de ces variables subit une série de transformations, comme la mise à l’échelle, pour adapter les données sonores aux besoins visuels du sketch.
Une partie intéressante du programme est la conversion d’une de ces variables flottantes en une valeur entière (son5_entier), illustrant comment les données sonores peuvent être manipulées et préparées pour différentes applications visuelles.
Le sketch utilise ensuite ces données audio traitées pour influencer visuellement deux principaux éléments graphiques : un rectangle et une courbe de Bézier. Le rectangle change de taille en fonction des variations sonores, créant un effet visuel dynamique qui réagit en temps réel au son capté. Les courbes de Bézier, quant à elles, utilisent les valeurs sonores pour ajuster leurs points de contrôle, créant un effet visuel qui représente la fluidité et la dynamique du son.
Le programme est conçu avec un souci du détail, incluant des commentaires utiles pour guider les utilisateurs à travers chaque étape du processus, de l’initialisation de la bibliothèque Minim à la construction des éléments visuels. La section draw() du programme, où se déroule l’animation, est structurée de manière à refléter clairement comment les données sonores sont transformées en visuels.
.
.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 |
// Version de IDE:Processing 3.3.4 // RedOhm // H-Mazelin 26/07/2017 // Au sommaire // // Integration de la bibliothéque // Configuration de la fonction minim // Mise à l'echelle de la valeur sonore // Utilisation de la valeur // Minim est une bibliothèque audio qui permet la manipulation // du son dans l’environnement Processing. import ddf.minim.*; // Création d'une variable qui contiendra le moteur Minim Minim minim; // Un AudioInput est une connexion à la source d'enregistrement // actuelle de l'ordinateur. AudioInput in; // declaration des variables son à virgule flottante float son; float son1; float son2; float son3; float son4; // creation d'une variable son5_entier int son5_entier; // La fonction setup () est exécutée une fois, lorsque le programme démarre. // Il sert à définir les propriétés d'environnement initiales telles que la // taille de l'écran et à charger des supports tels que des images et des polices // au démarrage du programme. void setup() { // definition de la taile de la fenetre // syntaxe : size (Hauteur fenetre,largeur fenetre ) size(1000,800); // definition « this » dans ce programme, sachez qu'il sert à indiquer à Processing // que ces instructions s'appliquent à « ce » programme. Minim a besoin de connaître // l'adresse de « ce » programme pour le faire communiquer avec la carte son de // votre ordinateur. minim = new Minim(this); // requête pour une entrée d'un certain taux d'échantillonnage in = minim.getLineIn(Minim.STEREO, 512); } //Le programme principal s’exécute par une boucle infinie appelée draw () void draw() { // *********** Présentation de l'exercice *************************** // // choix de la couleur du fond de la fenetre // syntaxe : background (rouge,vert,bleu ) // valeur du rouge de 0 à 255 iden pour les autre couleurs // affichage du fond de l'ecran en blanc background(255,255,255); // Fill : Définit la couleur utilisée pour remplir les formes. // fill(r,g,b); // r = pour rouge // g = pour le vert // b = pour le bleu fill(0,0,0); // Choix de la taille de la police // syntaxe => textSize( taille ) // Taille => La taille des caractères est en de pixels. textSize(32); // Affichage d'un texte à l'écran // text (texte,x,y); // x => coordonnée x du texte // y => coordonnée y du texte text("Utilisation de l'entrée son " , 300,50); //*********** Récupération du niveau sonore ********************** // // transfert de la valeur du volume du canal audio // vers la variable son son=(in.mix.level()); // Mise a l'echelle et augmentation de la valeur son1=son*200; // Mise a l'echelle et augmentation de la valeur son2=son*100; // Mise a l'echelle et augmentation de la valeur son3=son*100; // *********** Affichage de la valeur de remise à l'echelle ********* // // Choix de la taille de la police // syntaxe => textSize( taille ) // Taille => La taille des caractères est en de pixels. textSize(20); // Affichage d'un texte à l'écran // text (texte,x,y); // x => coordonnée x du texte // y => coordonnée y du texte text("Valeur du son brute => "+ son , 100,200); text("Valeur du son avec un coef multiplicateur de 100 => "+ son1 , 100,230); // ******** Mise a l'echelle d'une valeur ********************** // // map(valeur, v_basse_e,v_haut_e,valeur_b_sortie,valeur_h_sortie) // valeur => valeur a etalonner // v_basse_e => limite inférieure de la plage actuelle de la valeur // v_haute_e => limite supérieure de la plage actuelle de la valeur // valeur_b_sortie => limite inférieure de la plage cible de la valeur // valeur_h_sortie => limite supérieure de la plage cible de la valeur son4=map(son3,1,40,0,10); text("Mise à l'echelle " + son4 ,100,330); text("map (variable son3 , 1 , 40 , 0 , 10) ",400,330 ); // ******** Convertion d'une variable flottante en entier *********** // valeur_entier = int(valeur flottante * 1.4); son5_entier = int(son4 * 1.4); // Affichage d'un texte à l'écran // text (texte,x,y); // x => coordonnée x du texte // y => coordonnée y du texte text("Conversion d'une variable flottante en entier => "+ son5_entier,100,360 ); // *********** Construction du rectangle *************************** // // Choix de la taille de la police // syntaxe => textSize( taille ) // Taille => La taille des caractères est en de pixels. textSize(16); // Affichage d'un texte à l'écran // text (texte,x,y); // x => coordonnée x du texte // y => coordonnée y du texte text("Affectation de la valeur audio " , 100,540); text("aux paramétres du rectangle " , 100,560); // Dessine un rectangle à l’écran avec tous les angles à 90° // rect(a, b, c, d); // a => coordonnée x du rectangle // b => coordonnée y du rectangle // c => largeur du rectangle // d => hauteur du rectangle rect(100,600,20+son1,20+son1); // ********** utilisation des parametres audio ******************* // pour activer la courbe de bezier // Affichage d'un texte à l'écran // text (texte,x,y); // x => coordonnée x du texte // y => coordonnée y du texte text("Affectation de la valeur audio " , 500,500); text("aux paramétres de la courbe de " , 500,520); text(" Bezier " , 500,540); // Pour dessiner une courbe de bézier, il faut définir quatre // points avec chaque fois 2 valeurs (x,y) . La première et la // dernière définiront le début et le fin de la courbe. Les deux // points intermédiaires définiront les contrôles de courbe // // bezier (ax,ay,c1x,c1y,c2x,c2y,bx,by) // ax,ay => définition du début de la courbe // c1x,c1y => premier contrôle de courbure // c2x,c2y => deuxième contrôle de courbure // bx,by => définition de la fin de la courbe bezier(500,600,550,600-son1,600,600-son1,650,600); bezier(500,600,550,600+son2,600,600+son2,650,600); } // ***************Procedure d'arret ************************ // il faut prévoir d'arréter la capture du son ainsi que la librairie // minim a la fin de l'execution du programme void stop() { minim.stop(); super.stop(); } |
.
Retour au sommaire.
Mise à jour le 21/07/2017 : Article traitant de La fonction image() dans Processing . Dessine une image sur l’espace de travail .
Sommaire :
Présentation de la fonction |
La fonction image() dessine une image sur l’espace de travail . Les images doivent être dans le répertoire « data » de l’esquisse pour se charger correctement. Sélectionnez «Ajouter un fichier …» dans le menu «Croquis» pour ajouter l’image au répertoire de données, ou faites simplement glisser déposer le fichier image sur l’espace de travail.
| Retour au sommaire |
Comment importer une image dans Processing ( Tutoriel ). |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 |
// // // // Comment importer une image dans Processing // // // Version de IDE:Processing 3.3.4 // RedOhm // H-Mazelin 18/07/2017 // création d'une variable Processing pour le fichier image // nom de la variable iris PImage iris; // La fonction setup () est exécutée une fois, lorsque le programme démarre. // Il sert à définir les propriétés d'environnement initiales telles que la // taille de l'écran et à charger des supports tels que des images et des polices // au démarrage du programme. void setup () { // definition de la taile de la fenetre // syntaxe : size (Hauteur fenetre,largeur fenetre ) size(1000,800); // loadImage() qui va aller chercher les pixels de l'image dans le fichier // et les importera dans notre variable nommée iris. iris = loadImage("iris_essai_png.png"); } //Le programme principal s’exécute par une boucle infinie appelée draw () void draw () { // choix de la couleur du fond de la fenetre // syntaxe : background (rouge,vert,bleu ) // valeur du rouge de 0 à 255 iden pour les autre couleurs // dans notre exemple blanc background(255,255,255); // parametre de la fonction (variableImage, x, y, largeur,hauteur). // variableImage => l'image à afficher // X => coordonnées en X de l'image // Y => coordonnées en Y de l'image // largeur => largeur de l'image à afficher // hauteur => hauteur de l'image à afficher // // ***************** utilisation de la fonction mouse **************** // // Utilisation de mouseX : La variable système mouseX contient toujours // la coordonnée horizontale actuelle de la souris. // Utilisation de mouseY : La variable système mouseY contient toujours // la coordonnée verticale actuelle de la souris. image(iris,10+mouseX,10+mouseY,60,60); } |
| Retour au sommaire |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 |
// // // // création d'un regard avec l'utilisation de la // courbe de Bezier et la fonction ellipse // // Version de IDE:Processing 3.3.4 // RedOhm // H-Mazelin 12/07/2017 // Déclaration des variables // Une variable est une donnée que l'ordinateur va stocker dans l'espace de sa mémoire // Il existe différents type de variables: // dans notre exemple . // int =>Les nombres entiers peuvent être compris entre 2 147 483 647 à - 2 147 483 648 // float => pour les nombres à virgule flottante " qui posséde un point décimal " // Modification de la valeur du premier rayon de courbure de mes yeux int be1; // Modification de la valeur du deuxième rayon de courbure de mes yeux int be2; // Valeur de déplacement de mes yeux int deplace_x; // Intervalle aléatoire pour le clignotement des yeux float r; // Intervalle aléatoire pour le déplacement des yeux float deplacement_x; // La fonction setup () est exécutée une fois, lorsque le programme démarre. // Il sert à définir les propriétés d'environnement initiales telles que la // taille de l'écran et à charger des supports tels que des images et des polices // au démarrage du programme. void setup () { // definition de la taile de la fenetre // syntaxe : size (Hauteur fenetre,largeur fenetre ) size(1000,600); } //Le programme principal s’exécute par une boucle infinie appelée draw () void draw () { // ************* clignotement des paupieres **************************** // Fonction random(valeur_mini,valeur_maxi) // Cette fonction génère 1 nombre aléatoire. Chaque fois que cette fonction // est sollicitée dans le programme, le nombre aléatoire sera compris entre // la valeur mini et maxi fixée entre parenthèses r = random(1,20); if (r>5 && r<6 ) { // transfert des valeurs pour le clignotement des paupieres be1=180; be2=170; } else { // transfert des valeurs par defaut be1=160; be2=140; } // ******** fin du teste de clignotement pour les paupieres *********** // ************* deplacement des yeux **************************** // Fonction random(valeur_mini,valeur_maxi) // Cette fonction génère 1 nombre aléatoire. Chaque fois que cette fonction // est sollicitée dans le programme, le nombre aléatoire sera compris entre // la valeur mini et maxi fixée entre parenthèses deplacement_x = random(1,40); // La ligne ci-dessous teste si le nombre aléatoire est compris entre la valeur // 5 et 6 si tel est le cas nous transférons la nouvelle valeur dans la variable // "déplacent_x", ce qui nous permettra de faire bouger l’œil. if (deplacement_x>5 && 6<deplacement_x ) { // force la variable à 8 deplace_x= 8; } else { // force la variable à 0 deplace_x= 0; } // ************* fin deplacement des yeux **************************** // choix de la couleur du fond de la fenetre // syntaxe : background (rouge,vert,bleu ) // valeur du rouge de 0 à 255 iden pour les autre couleurs background(0,0,0); // Définit la couleur utilisée pour remplir les formes. // dans notre exemple 255 = noir fill(255); // **************** Oeil gauche ************************* // bezier (ax,ay,c1x,c1y,c2x,c2y,bx,by); // ax,ay => definition du debut de la courbe // c1x,c1y => premier controle de courbure // c2x,c2y => deuxieme controle de courbure // bx,by => definition de la fin de la courbe // bezier(10,100, 50,50, 150,50, 190,100); bezier(300,176,350,be2,400,be1,450,200); bezier(300,176,350,230,400,220,450,200); // **************** Oeil droit ************************* // bezier (ax,ay,c1x,c1y,c2x,c2y,bx,by); // ax,ay => definition du debut de la courbe // c1x,c1y => premier controle de courbure // c2x,c2y => deuxieme controle de courbure // bx,by => definition de la fin de la courbe // bezier(10,100, 50,50, 150,50, 190,100); bezier(550,200,600,be1,650,be2,700,176); bezier(550,200,600,220,650,230,700,176); // Dessine une ellipse (ovale) à l’écran. Une ellipse de // même largeur et hauteur est un cercle. Les 2 premiers // paramètres définissent l’emplacement sur l’écran . // ellipse(a, b, c, d); // a => coordonnée x de l’ellipse // b => coordonnée y de l’ellipse // c => largeur de l’ellipse // d => hauteur de l’ellipse ellipse(380+deplace_x,193,35,35); ellipse(610+deplace_x,193,35,35); // Définit la couleur utilisée pour remplir les formes. // dans notre exemple le gris fill(128,128,128); ellipse(380+deplace_x,193,10,10); ellipse(610+deplace_x,193,10,10); // La fonction println () écrit sur la zone de la console, // le rectangle noir au bas de l'environnement de traitement. // Cette fonction est souvent utile pour regarder les données // générées par un programme. print("Valeur du nombre aleatoire pour le clignotement de yeux => "+ r); println(" Valeur du nombre aleatoire pour le deplacement des yeux => "+ r); // La fonction delay () arrête l'execution du programme pendant un temps spécifié. // Les délais sont spécifiés en millièmes de seconde. Par exemple, // le délai d' exécution (3000) arrête le programme pendant trois // secondes et le délai (500) arrête le programme pendant une demi-seconde. delay(100); } |
programme pour affiche une valeur audio
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 |
// // // // Minim est une bibliothèque audio qui permet la manipulation // du son dans l’environnement Processing. import ddf.minim.*; // Création d'une variable qui contiendra le moteur Minim Minim minim; AudioInput in; // declaration des variables son à virgule flottante float son; float son1; float son2; float son3; float son4; void setup() { // definition de la taile de la fenetre // syntaxe : size (Hauteur fenetre,largeur fenetre ) size(1000,800); // definition « this » dans ce programme, sachez qu'il sert à indiquer à Processing // que ces instructions s'appliquent à « ce » programme. Minim a besoin de connaître // l'adresse de « ce » programme pour le faire communiquer avec la carte son de // votre ordinateur. minim = new Minim(this); in = minim.getLineIn(Minim.STEREO, 512); } //Le programme principal s’exécute par une boucle infinie appelée draw () void draw() { // choix de la couleur du fond de la fenetre // syntaxe : background (rouge,vert,bleu ) // valeur du rouge de 0 à 255 iden pour les autre couleurs // affichage du fond de l'ecran en blanc background(255,255,255); // Fill : Définit la couleur utilisée pour remplir les formes. // fill(r,g,b); // r = pour rouge // g = pour le vert // b = pour le bleu fill(0,0,0); // Choix de la taille de la police // syntaxe => textSize( taille ) // Taille => La taille des caractères est en de pixels. textSize(32); // Affichage d'un texte à l'écran // text (texte,x,y); // x => coordonnée x du texte // y => coordonnée y du texte text("Utilisation de l'entrée son " , 300,50); // transfert de la valeur du volume du canal audio // vers la variable son son=(in.mix.level()); // Mise a l'echelle et augmentation de la valeur son1=son*100; // Mise a l'echelle et augmentation de la valeur son2=son*50; // Mise a l'echelle et augmentation de la valeur son3=son*100; // ******** Mise a l'echelle d'une valeur ********************** // // map(valeur, v_basse_e,v_haut_e,valeur_b_sortie,valeur_h_sortie) // valeur => valeur a etalonner // v_basse_e => limite inférieure de la plage actuelle de la valeur // v_haute_e => limite supérieure de la plage actuelle de la valeur // valeur_b_sortie => limite inférieure de la plage cible de la valeur // valeur_h_sortie => limite supérieure de la plage cible de la valeur son4=map(son3,1,40,0,10); // ******** Convertion d'une variable flottante en entier *********** // valeur_entier = int(valeur flottante * 1.4); // *********** Affichage de la valeur de remise à l'echelle ********* // // Choix de la taille de la police // syntaxe => textSize( taille ) // Taille => La taille des caractères est en de pixels. textSize(20); // Affichage d'un texte à l'écran // text (texte,x,y); // x => coordonnée x du texte // y => coordonnée y du texte text("Valeur du son brute => "+ son , 100,200); text("Valeur du son avec un coef multiplicateur de 100 => "+ son1 , 100,230); text("Mise à l'echelle " + son4 ,100,330); text("map (variable son3 , 1 , 40 , 0 , 10) ",400,330 ); // Choix de la taille de la police // syntaxe => textSize( taille ) // Taille => La taille des caractères est en de pixels. textSize(16); // Affichage d'un texte à l'écran // text (texte,x,y); // x => coordonnée x du texte // y => coordonnée y du texte text("Affectation de la valeur audio " , 100,540); text("aux paramétres du rectangle " , 100,560); rect(100,600,20+son1,20+son1); // utilisation des parametres audio pour activer la courbe // de bezier // Affichage d'un texte à l'écran // text (texte,x,y); // x => coordonnée x du texte // y => coordonnée y du texte text("Affectation de la valeur audio " , 500,500); text("aux paramétres de la courbe de " , 500,520); text(" Bezier " , 500,540); bezier(500,600,550,600-son1,600,600-son1,650,600); bezier(500,600,550,600+son2,600,600+son2,650,600); } void stop() { minim.stop(); super.stop(); } |
Mise à jour le 10/09/2017 : La liaison série est un protocole de communication indispensable entre l’ordinateur et la carte Arduino ( ou bien un autre type de carte ) , via le câble de communication USB.Dans cet article , nous vous donnons quelques exemples avec des tutoriels pour vous familiariser à ce genre de communication série.
Sommaire :
– La communication série –
|
Programme pour Arduino ( AP001-A)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 |
// // // // ***************************************************** // * RedOhm * // * * // * Lecture d'une valeur sur la carte Arduino * // * via le port serie * // * * // * code programme : AP001-A * // * * // * 13/08/2017 * // * H.Mazelin * // ***************************************************** // Déclare une variable ( valeur ) de type int non-signée. ce type de variables // unsigned int stocke uniquement des valeurs positives, dans une fourchette // allant de 0 à 65535 unsigned int valeur ; // Un programme Arduino doit impérativement contenir la fonction "setup" // Elle ne sera exécuter une seule fois au démarrage du microcontroleur // Elle sert à configurer globalement les entrées sorties void setup() { //ouvre le port série et fixe le debit de communication à 9600 bauds Serial.begin(9600); } //Le programme principal s’exécute par une boucle infinie appelée Loop () void loop() { // incrémente la variable valeur de un, sans modifier la variable valeur valeur = valeur +1 ; // Affiche les données sur le port série suivi d'un caractère de "retour de chariot" //(ASCII 13, or '\r') et un caractère de "nouvelle ligne" (ASCII 10, or '\n'). Serial.println(valeur); // Réalise une pause dans l'exécution du programme pour la durée (en millisecondes) // soit 2000 ms = 2 secondes delay(2000); } |
.
Programme pour Processing ( AP001-P )
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 |
// // // // ***************************************************** // * RedOhm * // * * // * Lecture d'une valeur sur la carte Arduino * // * via le port serie * // * * // * code programme : AP001-P * // * * // * 13/08/2017 * // * H.Mazelin * // ***************************************************** // Cette librairie permet de communiquer avec l'Arduino // il esn indispensable de l'installer pour communiquer import processing.serial.*; // Crée un objet de type myPort Serial port_de_com; // Declaration de la variable -> valeur_recu // Cette fonction (string ) sert à stocker du texte. // Dans notre exemple pour les données reçues sur le port série String valeur_recu; // La fonction setup () est exécutée une fois, lorsque le programme démarre. // Il sert à définir les propriétés d'environnement initiales telles que la // taille de l'écran et à charger des supports tels que des images et des polices // au démarrage du programme. void setup() { // definition de la taille de la fenetre // syntaxe : size (Hauteur fenetre,largeur fenetre ) size(1000,600); // choix de la couleur du fond de la fenetre // syntaxe : background (rouge,vert,bleu ) // valeur du rouge de 0 à 255 iden pour les autre couleurs // affichage du fond en jaune background(255,255,128); // Ouverture du port de communication // par defaut sur le systeme Windows , cela ouvre generalement // le port COM 1 String nom_du_port = Serial.list()[0]; // initialise la connexion série à 9600 bauds // IMPORTANT : régler le recepteur avec la même valeur de transmission // soit dans notre exemple la carte Arduino port_de_com = new Serial(this, nom_du_port, 9600); } //Le programme principal s’exécute par une boucle infinie appelée draw () void draw() { // --------------- Affichage du titre ----------------------- // Fill : Définit la couleur utilisée pour remplir les formes. // fill(r,g,b); // r = pour rouge // g = pour le vert // b = pour le bleu fill(0,0,0); // Choix de la taille de la police // syntaxe => textSize( taille ) // Taille => La taille des caractères est en de pixels. textSize(32); // Affichage d'un texte à l'écran // text (texte,x,y); // x => coordonnée x du texte // y => coordonnée y du texte text("Lecture des informations envoyer par Arduino", 220, 75); // ---------- Fin de l'affichage du titre ----------------------- // --------- Controle du port série ---------------------------- // On vérifie si les données ou informations sont disponibles // sur le port série.Si oui , on exécute le code ci-dessous // entre crochets if ( port_de_com.available() > 0) { // Comme des données sont disponibles sur le port série, alors // on fixe celle-ci dans la variable valeur_recu valeur_recu = port_de_com.readStringUntil('\n'); } // --------------- fin du controle du port série ------------- // ------------------- Aide a la mise au point ---------------- // La fonction println () écrit sur la zone de la console // (le rectangle noir en bas de l'environnement de l'écran de // Processing ) // ** A savoir ** // Cette fonction est souvent utile pour vérifier le bon fonctionnement // du programme .Notez que la fonction est relativement lente .Elle ne // fonctionne bien que sur des contrôles relativement lents comme dans // notre exemple. On peut donc désactiver cette ligne de code qui ne sert // que pour la mise au point . println(valeur_recu); // ----------- Fin de la mise au point -------------------------- // ----- Affichage de valeur du compteur de la carte Arduino --- // Désactive le dessin des contours de la forme dans notre cas le // rectangle noStroke(); // Fill : Définit la couleur utilisée pour remplir les formes. // dans notre exemple le rectangle fill(255,255,128); // On dessine rect(435,259,100,20); // Choix de la taille de la police textSize(16); // Fill : Définit la couleur utilisée pour remplir les formes. // dans notre exemple le texte fill(0,0,0); // Affichage d'un texte à l'écran // suivi de la valeur du compteur de la carte Arduino text("Valeur du compteur de la carte Arduino -> "+ valeur_recu, 115, 275); // ---- Fin du traitement de l'affichage du compteur --------- } |
| Retour au sommaire . |
– La communication série –Lecture de 3 valeurs sur la carte Arduino
|
Tutoriel : Animation d’une forme sous Processing avec utilisation de la communication série
Pour plus d’information sur la carte Arduino Mega => oui j’en besoin
Programme pour Arduino ( Version 1.8.3 )
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 |
// // // /* * RedOhm * * * Transfert des informations du joystock vers le port de * communication * * * Le 28/08/2017 * H.Mazelin * * */ // Déclaration et initialisation des broches d'entrée // Le signal de l'axe X SUR A0 int JoyStick_X = A0; // Le signal de l'axe Y SUR A1 int JoyStick_Y = A1; // L'information du bouton sur la pin 3 int Bouton = 3; /* * Un programme Arduino doit impérativement contenir cette fonction . * Elle ne sera exécuter une seule fois au démarrage du microcontroleur * Elle sert à configurer globalement les entrées sorties * */ void setup () { //le potentiometre JoyStick_X est une entrée pinMode (JoyStick_X, INPUT); //le potentiometre JoyStick_Y est une entrée pinMode (JoyStick_Y, INPUT); //l'inter Bouton est une entrée pinMode (Bouton, INPUT); //Cette fonction a pour but de de forcer une entrée dans un état //défini. Dans notre exemple nous le forçons à l’État HAUT digitalWrite(Bouton, HIGH); //ouvre le port série et fixe le debit de communication à 9600 bauds Serial.begin (9600); } //Le programme principal s’exécute par une boucle infinie appelée Loop () void loop () { // Déclare des variables de type "virgule-flottante", c'est à dire des nombres // à virgules. Les nombres à virgule sont souvent utilisés pour l'expression // des valeurs analogiques et continues float x, y; // Déclare une variable ( etat_du_bouton ) de type int int etat_du_bouton; // Lit la valeur de la tension présente sur la broche spécifiée // dans notre cas la valeur JoyStick_X x = analogRead (JoyStick_X); // Lit la valeur de la tension présente sur la broche spécifiée // dans notre cas la valeur JoyStick_Y y = analogRead (JoyStick_Y); // Lit l"état (= le niveau logique) d'une broche précise en entrée // numérique dans notre cas (bouton) etat_du_bouton = digitalRead (Bouton); // ecrit les données sur le port série Serial.print(x); Serial.print(';'); Serial.print(y); Serial.print(';'); // ecrit les données sur le port série // puis effectue un saut de ligne avec la fonction Serial.println Serial.println(etat_du_bouton); // Réalise une pause dans l'exécution du programme pour la durée //(en millisecondes) indiquée en paramètre. delay (50); } |
| Retour au sommaire . |
Programme pour Processing ( Version 3.3.4 )
Code programme : AP002-A
Nom du programme : communication_processing_joy_ky023
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 |
// // // // // // ********************************************************* // * RedOhm * // * * // * Lecture de 3 valeurs sur la carte Arduino * // * via le port serie et animation * // * d'un rectangle sur l'ecran * // * * // * code programme : AP002-A * // * Nom du programme : communication_processing_joy_ky023 * // * * // * 28/08/2017 * // * B.Benoit & H.Mazelin * // ********************************************************* // Cette librairie permet de communiquer avec l'Arduino // il est indispensable de l'installer pour communiquer import processing.serial.*; // Definition du port cible, en minuscules. static String ARDUINO_PORT = "com15"; // Crée un objet de type myPort Serial myPort; // Variable pour les données reçues sur le port serie String message; // Fonction permettant de vérifier l'existence du port cible souhaité. boolean checkSerialPort(final String targetPort) { // Récupération de la liste des ports disponibles. final String[] serialPortList = Serial.list(); // Itération sur chacun de ces ports. for (int i=0; i < serialPortList.length; i++) // Comparaison du nom du port (en minuscules), avec le port cible. if (serialPortList[i].toLowerCase().equals(targetPort)) return true; // Le port n'a pas été trouvé ! return false; } void setup() { // Fixe la taille de la fenêtre graphique en pixels (100x100 par défaut) // pour les parametre longeur , hauteur // et fixe le mode graphique cette commande est optionnel size(1000, 600, P3D); // Verification de l'existence du port cible. if (!checkSerialPort(ARDUINO_PORT)) { println("Impossible de trouver le port '" + ARDUINO_PORT + "'. Veuillez vérifier la configuration et la bonne connexion."); // Demande de sortie (différée) du programme. exit(); // Sortie immédiate du setup(). return; } // Initialisation concrète du port sur lequel communiquer avec l'Arduino. println("Initialisation du port '" + ARDUINO_PORT + "'."); myPort = new Serial(this, ARDUINO_PORT, 9600); myPort.bufferUntil('\n'); } void draw() { // Vérification de la disponibilité du port initialisé. if (myPort.available() > 0) { // Récupération des prochaines valeurs lissées. float[] averageValues = getAverageValues(1); // Convertion des valeurs reçues depuis le Joystick. // La valeur brute 1 va être utilisée sur l'axe Y. // La valeur brute 2 va être utilisée sur l'axe X. // La troisième valeur correspond à l'état du bouton du Joystick // => 1 = bouton NON pressé (valeur par défaut), 0 = bouton pressé float valeurBrute1 = averageValues[0]; float valeurBrute2 = averageValues[1]; boolean etatBouton = !(averageValues[2] == 1); // Mapping des valeurs en angle (exprimé en degré). // La plage de valeurs du Joystick est de 0 à 1023. float x = map(valeurBrute2, 0, 1023, 0, 360); float y = map(valeurBrute1, 0, 1023, 0, 360); // Si le bouton est pressé, on allume une lumière, et active un effet de zoom. if (etatBouton) { lights(); //scale(1.1); } // Positionnement par défaut de l'affichage. background(0); translate(width/2, height/2); // Ajout d'un offset, pour que la position de départ soit celle d'une boite posée sur une surface plane. // Cela est variable et à ajuster en fonction du matériel utilisé (ici Joystick). x += 90; y -= 174; rotateX(radians(x)); rotateY(radians(y)); rotateZ(radians(90)); // Remplissage de la boîte d'une couleur différente selon l'état du bouton du Joystick. if (etatBouton) fill(255,0,0); else fill(128,128,128); stroke(255); box(80,240,20); } } // *************************** creation de la fonction ******************************** // // fixe un nombre pour un eventuel lissage // Controle du format // convertion en entier // Envoie des 3 valeurs, sous la forme d'un tableau. float[] getAverageValues(int measureCount) { int iterationCount = measureCount; float valeurBrute1 = 0.0, valeurBrute2 = 0.0, etatBouton = 0.0; // Boucle jusqu'à ce que l'on obtienne le nombre de mesures demandées // (en ne prenant pas en compte tous les problèmes de format, de convertion // en entiers ...). while (true) { // Lecture du prochain message disponible. message = myPort.readStringUntil('\n'); // Vérification : on s'assure qu'un message AVEC fin de ligne est bien disponible // sur le port,sinon on ne fait rien de plus dans cette exécution de draw(). // L'exécution suivante prendra en charge les messages en attente. if (message == null) continue; // Décodage du message reçu; il doit impérativement respecter le format : x;y final String[] values = message.split(";"); if (values.length != 3) { println("Le message suivant ne respecte pas le format attendu (x;y): " + message); continue; } // Convertion des valeurs reçues en entiers (en gérant le cas où l'une des // valeurs n'est pas un entier). try { float nextvaleurBrute1 = Float.parseFloat(values[0].trim()); float nextvaleurBrute2 = Float.parseFloat(values[1].trim()); float nextetatBouton = Float.parseFloat(values[2].trim()); // Prise en compte de ces nouvelles valeurs (pour le moment, on somme toutes les valeurs). valeurBrute1 += nextvaleurBrute1; valeurBrute2 += nextvaleurBrute2; etatBouton += nextetatBouton; } catch(NumberFormatException e) { // Affichage d'un message d'erreur. println("Impossible de convertir l'une des valeurs en entier ... le message suivant est donc totalement ignoré : " + message); e.printStackTrace(); continue; } // Arrivé ici, on a la certitude d'avoir bien reçu et pris en compte une // nouvelle valeur, au bon format.C'est ici que l'on gère le nombre d'itération, // et la condition d'arrêt de la boucle infinie (while(true)). if (--iterationCount <= 0) break; } // Envoie des 3 valeurs lissées, sous la forme d'un tableau. return new float[]{valeurBrute1/measureCount, valeurBrute2/measureCount, etatBouton/measureCount}; } |
| Retour au sommaire . |
Mise à jour le 08/07/2017
Sommaire :
| Retour au sommaire |
001 – Exemple pour écrire un texte sur l’écran avec , choix de la couleur du texte , de la taille , du positionnement du texte et enfin le contenu . |
Exemple de programme :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 |
// // // Exemple ecrire un texte sur l'ecran // // Choisir la couleur du texte // choisir la taille du texte // Positionner le texte sur l'ecran et donner le contenue du texte // // H-Mazelin 23/06/2017 // La fonction setup () est exécutée une fois, lorsque le programme démarre. // Il sert à définir les propriétés d'environnement initiales telles que la // taille de l'écran et à charger des supports tels que des images et des polices // au démarrage du programme. void setup () { // definition de la taile de la fenetre // syntaxe : size (Hauteur fenetre,largeur fenetre ) size(1000,800); } //Le programme principal s’exécute par une boucle infinie appelée draw () void draw () { // choix de la couleur du fond de la fenetre // syntaxe : background (rouge,vert,bleu ) // valeur du rouge de 0 à 255 iden pour les autre couleurs // affichage du fond de l'ecran en blanc background(255,255,255); // Fill : Définit la couleur utilisée pour remplir les formes. // fill(r,g,b); // r = pour rouge // g = pour le vert // b = pour le bleu fill(0,0,0); // Choix de la taille de la police // syntaxe => textSize( taille ) // Taille => La taille des caractères est en de pixels. textSize(32); // Affichage d'un texte à l'écran // text (texte,x,y); // x => coordonnée x du texte // y => coordonnée y du texte text("Bonjour de l'équipe RedOhm ", 220, 75); // Choix de la taille de la police 18 pixels textSize(18); // Affichage d'un texte à l'écran text("Bienvenue sur RedOhm.fr ", 15, 150); // Choix de la taille de la police 15 pixels textSize(15); // Affichage d'un texte à l'écran text("Nous sommes une équipe de passionnés de robotique, électronique, ", 15, 190); text("mécanique et nous partageons ici le fruit de notre travail.", 520, 190); } |
| Retour au sommaire | Menu langage Processing |
010 – Comment déplacer un texte avec la fonction translate sans effacement de l’ancienne position |
Exemple de programme :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 |
// // Comment déplacer un texte avec la commande translate // sans effacement de l'ancienne position // // H-Mazelin le 12/06/2017 // Declare la variable X // Rappel sur la fonction d'une variable :On peut définir une variable comme // une boite ou l’on stock des balles .Une variable est une boite ou // l’on stock un nombre ,et comme il existe une multitude de nombres: // Exemple entiers ,décimaux etc …Il faut donc assigner un type à cette // variable . int x; // La fonction setup () est exécutée une fois, lorsque le programme démarre. // Il sert à définir les propriétés d'environnement initiales telles que la // taille de l'écran et à charger des supports tels que des images et des polices // au démarrage du programme. void setup () { // definition de la taile de la fenetre // syntaxe : size (Hauteur fenetre,largeur fenetre ) size(1000,600); // choix de la couleur du fond de la fenetre // syntaxe : background (rouge,vert,bleu ) // valeur du rouge de 0 à 255 iden pour les autre couleurs background(255,255,255); } //Le programme principal s’exécute par une boucle infinie appelée draw () void draw () { // Boucle comptant de 0 a 10 avec un increment de 1 // for (initialisation ; condition ; increment) // entre crochet { instructions executees dans la boucle } for (x=0;x<10;x++) { // Fill : Définit la couleur utilisée pour remplir les formes. // Syntaxe => fill(r,g,b); // r = pour rouge // g = pour le vert // b = pour le bleu fill(0); // translate => permet de faire une translation au système de coordonnées // Cette fonction est additionnelle et s'appliquent à tout ce qui se passe // dans une boucle comme dans notre exemple // est donc la fonction accumulent l'effet. // Syntaxe translate (x,y); // x => deplacer la coordonnée de gauche vers la droite // y => deplacer la coordonnée du haut vers le bas translate(20,20); // Affichage d'un texte à l'écran // Syntaxe => text (texte,x,y); // x => coordonnée x du texte // y => coordonnée y du texte text("RedOhm 2017",0,0); } } |
Résultat du programme comment déplacer un texte avec la commande translate – RedOhm
Comment déplacer un texte avec la commande translate – RedOhm
| Retour au sommaire | Menu langage Processing |
Mise à jour le 19/06/2017
Sommaire :
| Retour au sommaire |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 |
// // // Exemple d'utilisation de la fonction mouseY // // Deplacement de forme avec la fonction mouseY // // H-Mazelin 15/06/2017 // La fonction setup () est exécutée une fois, lorsque le programme démarre. // Il sert à définir les propriétés d'environnement initiales telles que la // taille de l'écran et à charger des supports tels que des images et des polices // au démarrage du programme. void setup () { // definition de la taile de la fenetre // syntaxe : size (Hauteur fenetre,largeur fenetre ) size(1000,800); } //Le programme principal s’exécute par une boucle infinie appelée draw () void draw () { // choix de la couleur du fond de la fenetre // syntaxe : background (rouge,vert,bleu ) // valeur du rouge de 0 à 255 iden pour les autre couleurs // affichage du fond de l'ecran en blanc background(255,255,255); // Creation d'un ligne qui se deplace en verticale // line(a,b,c,d) // a => coordonnées horizontal de depart // b => coordonnées vertical de depart defini par mouseY // a => coordonnées horizontal d'arrivée // b => coordonnées vertical d'arrivée defini par mouseY line(100, mouseY, 200, mouseY); // Creation d'un rectangle qui se deplace en verticale // rect(x,y,largeur,longueur ); // les 2 premiers paramètres définissent l'emplacement du coin // supérieur gauche // x => la valeur horizontal horizontal de la position de // la forme // y => la valeur vetical de la position de la forne est // défini dans ce cas par mouseY // largeur => largeur du rectangle // longueur => longueur du rectangle // par defaut les angles du rectangles sont = 90° rect(250, mouseY, 80, 80); // Creation d'un cercle qui se deplace en verticale // ellipse(x,y,largeur,hauteur); // x => la valeur horizontal de la position de la forme // y => la valeur vetical est défini dans ce cas par mouseY // largeur => grandeur du diamètre sur l'axe horizontal // hauteur => diamètre sur l'axe vertical ellipse(400, mouseY, 80, 80); } |
| Retour au sommaire | Menu langage Processing |