Etape 1: Le Code
1)
Télécharger traitement. Le traitement est un environnement de programmation qui ressemble et se sent identique à l’environnement de programmation Arduino. Il est également livré au même prix, ce qui signifie que c’est gratuit. Cliquez ici pour télécharger. Mis en place comme vous configurer votre logiciel Arduino. Il fonctionne comme l’Arduino IDE.
Traitement peut être utilisé pour afficher des images, des lignes ou des objets et interagir avec eux. Il s’agit de ma première expérience avec le programme.
2)
Selon le nombre de canaux vous aimez ai, téléchargez l’un des « croquis Arduino"illustrés ci-dessous dans votre Arduino. Le code pour envoyer et recevoir des données a été basé sur le code dans ce chapitre du grand livre qui explique comment faire pour envoyer plusieurs champs de texte d’un Arduino à l’ordinateur et le traitement avec le traitement.
3)
Puis vous prenez le respectifs « croquis de traitement » par en dessous et copiez dans le traitement
4)
Changer le « chemin » dans la dernière ligne du code dans un chemin d’accès de votre choix.
5)
Exécutez-le en traitement.
6)
Assurez-vous que vos signaux ne dépassent pas 5V avant de vous connecter à :
Canal 1 = > analogique pin0
Canal2 = > analogique pin1
Canal3 = > broche analogique 2
Notes :
- Les esquisses de traitement utilisent port sΘrie 0 car il est standard. Vous devrez peut-être ajuster cette valeur si vous utilisez un autre port série.
- J’ai documenté à chaque étape du programme avec beaucoup de commentaires. Le code devrait être ainsi "s’expliquer".
- J’ai trouvé expérimentalement que pour certaines configurations, que les données ne peuvent pas figurer en temps réel en raison de plusieurs raisons interconnectées :
- Le retard qui est défini dans le programme Arduino n’est pas assez grand. = > Trop grand nombre de données est envoyé. = > Le temps de traitement s’accumule. = > Les données sont affichées avec un délai. Pour tester en cas de retard, je suis passé manuellement l’alimentation qui était connectée aux entrées analogiques de mon Arduino et le tout en observant la réaction de tension affichée par traitement. J’ai fait cela pendant une période prolongée de temps. Si la réponse est resté immédiate, je suis resté convaincu.
- Si vous zoomez dans avec « + » vous afficher moins de données. Cela a un effet direct sur le risque de retards, car moins délai de traitement est nécessaire.
- La fenêtre est trop large. = > Trop nombreux x-valeurs ont besoin d’être déplacé. = > Trop bien le temps nécessaire pour les calculs. = > j’ai choisi une taille de fenêtre beaucoup plus petite que la taille de mon écran pour répondre à cet effet.
Appréciez les canaux multiples sur vos pauvres-de l’homme-Oscilloscope et laissez-moi savoir si vous vous avérez justement venu avec aucune amélioration.
Arduino code de 2 canaux :
/ * CommaDelimitedOutput croquis * /
#define ANALOG_IN_Ch1 0
#define ANALOG_IN_Ch2 1
void setup()
{
Serial.Begin(9600) ;
}
void loop()
{
int val1 = analogRead(ANALOG_IN_Ch1) ; / * Lit les valeurs de Pin0 analogique = canal 1 * /
int val2 = analogRead (ANALOG_IN_Ch2) ; / * Lit les valeurs de Pin1 analogique = canal2 * /
Serial.Print('H') ; / * En-tête unique pour identifier le début du message * /
Serial.Print(",") ;
Serial.Print(val1,DEC) ;
Serial.Print(",") ;
Serial.Print(val2,DEC) ;
Serial.Print(",") ; / * Notez qu’une virgule est envoyée après le dernier champ * /
Serial.println() ; / * Envoyer un cr/lf * /
Delay(50) ; Cela peut être en mesure d’être plus rapide que 50ms
}
Code de 3 canaux Arduino :
/ * CommaDelimitedOutput croquis * /
#define ANALOG_IN_Ch1 0
#define ANALOG_IN_Ch2 1
#define ANALOG_IN_Ch3 2
void setup()
{
Serial.Begin(9600) ;
}
void loop()
{
int val1 = analogRead(ANALOG_IN_Ch1) ; / * Lit les valeurs de Pin0 analogique = canal 1 * /
int val2 = analogRead (ANALOG_IN_Ch2) ; / * Lit les valeurs de Pin1 analogique = canal2 * /
val3 int = analogRead (ANALOG_IN_Ch3) ; / * Lit les valeurs de code Pin2 analogique = canal3 * /
Serial.Print('H') ; / * En-tête unique pour identifier le début du message * /
Serial.Print(",") ;
Serial.Print(val1,DEC) ;
Serial.Print(",") ;
Serial.Print(val2,DEC) ;
Serial.Print(",") ;
Serial.Print(val3,DEC) ;
Serial.Print(",") ; / * Notez qu’une virgule est envoyée après le dernier champ * /
Serial.println() ; / * Envoyer un cr/lf * /
Delay(50) ;
}
Code de traitement de 2 canaux :
/*
* Oscilloscope
* Donne un rendu visuel de trois broches analogiques en temps réel.
*
* Ce logiciel développe le volume de canal d’une version antérieure.
* La version précédente était un projet qui fait partie du projet Accrochages
* Voir http://accrochages.drone.ws
*
* L’auteur de ce logiciel adapté n’a aucune relation d’Accrochages.
* Il les remercie pour le grand modèle et l’inspiration d’écrire ce logiciel.
*
* La déclaration suivante faisait partie du logiciel original.
* C’est pour votre information.
*
* (c) 2008 Sofian Audry (info
*
* Ce programme est un logiciel libre : vous pouvez le redistribuer et/ou le modifier
* elle aux termes de la GNU General Public License telle que publiée par
* la Free Software Foundation, soit la version 3 de la licence, ou
* (à votre choix) toute version ultérieure.
*
* Ce programme est distribué dans l’espoir qu’il sera utile,
* mais sans aucune garantie ; sans même la garantie implicite de
* Qualité marchande ou ADEQUATION a un usage particulier. Voir le
* GNU General Public License pour plus de détails.
*
* Vous devriez avoir reçu une copie de la GNU General Public License
* Parallèlement à ce programme. Si non, voir < http://www.gnu.org/licenses/>.
*/
Import processing.serial.* ;
Serial myPort ; / * Créer objet de série classe * /
EN-tête de char = « H » ; / * caractère pour identifier le début d’un message * /
court-LF = 10 ; / * Saut de ligne ASCII * /
portIndex court = 0 ; / * détermine l’USB port utilisé * /
int [] val = {-1, -1} ; / * Variable utilisée pour la fonction de getY, 2 positions pour 2 canaux * /
int [] valuesCh1 ; / * Les trois variables contiendra les données de la fenêtre dans la mémoire, afin qu’ils peuvent être poussés et affiche * /
int [] valuesCh2 ;
zoom du flotteur ; / * Définir « zoom » en tant que variable à virgule flottante * /
void setup()
{
Size(1014, 690) ; / * Ouvre une fenêtre de taille spécifique, la taille maximum de mon écran d’ordinateur portable, des problèmes de retard peuvent survenir * /
taille (600, 400) ; / * plus petit écran = > inférieur à calculer = > aucun problème de retard * /
myPort = nouvelle série (ce, Serial.list() [portIndex], 9600) ; / * Ouvrir le port qui est connecter la platine et utilisent la même vitesse (9600bps) * /
valuesCh1 = new int [Largeur] ; / * Définir tableau avec autant d’éléments que x pixels dans la fenêtre, utilisée pour le traçage des données du canal 1 * /
valuesCh2 = new int [Largeur] ; / *... de canal2 * /
Zoom = 1.0f ; / * Début avec 1 x facteur de zoom * /
Smooth() ; / * Dessiner des images avec des bords lisses * /
}
/ * Cette fonction convertit une valeur de données de canal en pixels illustrés de
* Sommet du graphe (qui est la position 0)
* Cette fonction retourne une valeur entière * /
int getY(int val)
{
Return (int) (hauteur - val/1023.0f * (hauteur - 1)) ;
}
/ * Fonction qui lit la chaîne de série de données qui ont été envoyées par l’arduino
* Met un tableau avec les trois valeurs de l’arduino
* Fonction est appelée en fonction du tirage au sort * /
int [] getData()
{
int [] ChValues = {-1, -1} ; / * Définir tableau pour cette fonction * /
Message de chaîne = myPort.readStringUntil(LF) ; / * Lire dans la chaîne de données série envoyée par arduino * /
Si (message! = null) / * cela uniquement lorsque la réception d’un message complet valide * /
{
String [] data = message.split(",") ; / * Diviser le message séparées par des virgules en ses segments * /
if(Data[0].charAt(0) == en-tête) / * cocher caractère d’en-tête dans le premier champ, toujours vrai pour le message complet * /
{
pour (int i = 1; j’ai < data.length-1; i ++) / * ignorer l’en-tête et résilier cr et lf = > oeil seulement sur les points de trois données * /
{
ChValues [i-1] = Integer.parseInt(data[i]) ; / * Écrire les données des canaux en tableau, je suis passé de données au tableau 1 en raison d’en-tête * /
}
}
}
Return ChValues ; / * Retourne un tableau ChValues qui contient les données des canaux * /
}
/ * Cette fonction pousse tous les points de données du une poste fenêtre vers la gauche, puis on ajoute le point de données qui a été lu juste * /
« PushValue » Sub (int [] value)
{
pour (int i = 0; i < largeur-1; i ++)
{
valuesCh1 [i] = valuesCh1 [i + 1] ; / * Déplace les données point par position * /
valuesCh2 [i] = valuesCh2 [i + 1] ;
}
valuesCh1 [largeur-1] = valeur [0] ; / * Ajouter point de données * /
valuesCh2 [largeur-1] = valeur [1] ;
}
/ * Cette fonction dessine les données dans la fenêtre * /
Sub drawLines()
{
int displayWidth = (int) (largeur / zoom) ; / * Calcule la largeur de la fenêtre, compte tenu de la x-change si un zoom a la valeur * /
int k = valuesCh1.length - displayWidth ; / * Cela calcule la position vers le haut à laquelle sont indiqués les points de données * /
int x0 = 0 ; / * x valeur, très à gauche de la fenêtre (= 0) est affecté à x0 et utilisé pour tous les canaux * /
int ya0 = getY(valuesCh1[k]) ; / * valeur y du dernier point indiqué est affectée à ya0 pour le canal 1 * /
yb0 int = getY(valuesCh2[k]) ; / * valeur y du dernier point indiqué est affectée à yb0 pour canal2 * /
pour (int i = 1; j’ai < displayWidth-1; i ++) / * boucle qui s’étend du point k au très droite de la fenêtre * /
{
k ++ ; / * Incrémentation k pour le prochain point de données * /
int x1 = (int) (j’ai * (largeur-1) / (displayWidth-1)) ; / * Calculer suivant x valeur * /
ya1 int = getY(valuesCh1[k]) ; / * Get prochaine valeur y pour canal 1 * /
yb1 int = getY(valuesCh2[k]) ; / * Obtenir la prochaine valeur y pour canal2 * /
strokeWeight(2) ; / * Dessiner des lignes plus épaisses * /
accident vasculaire cérébral (255, 0, 0) ; / * Dessiner une ligne rouge pour canal 1 * /
ligne (x0, ya0, x1, ya1) ; / * Tracer un segment de ligne pour canal 1 * /
accident vasculaire cérébral (0, 255, 0) ; / * Dessiner une ligne verte pour canal2 * /
ligne (x0, yb0, x1, yb1) ; / * Tracer un segment de ligne pour canal2 * /
x0 = x1 ; / * Maj x valeur pour calculer des segments de ligne suivante * /
ya0 = ya1 ; / * Changer les valeur y pour 1 afin de calculer des segments de ligne suivante * /
YB0 = yb1 ; / * Changer les valeur y pour canal2 calculer des segments de ligne suivante * /
}
}
/ * Cette fonction dessine des lignes de la grille dans la fenêtre
* J’ai espacé les lignes afin qu’elles représentent des étapes 10 % et 20 % en 2 couleurs différentes
Pour les signaux de 5V max, c’est pas 0.5 & 1.0V * /
Sub drawGrid()
{
accident vasculaire cérébral (150, 150, 0) ;
ligne (0, hauteur/5, width, height/5) ;
ligne (hauteur 0, * 2/5, largeur, hauteur * 2/5) ;
ligne (hauteur 0, * 3/5, largeur, hauteur * 3/5) ;
ligne (hauteur 0, * 4/5, largeur, hauteur * 4/5) ;
accident vasculaire cérébral (150, 150, 150) ;
ligne (0, hauteur/10, largeur, hauteur/10) ;
ligne (hauteur 0, * 3/10, largeur, hauteur * 3/10) ;
ligne (hauteur 0, * 5/10, largeur, hauteur * 5/10) ;
ligne (hauteur 0, * 7/10, largeur, hauteur * 7/10) ;
ligne (hauteur 0, * 9/10, largeur, hauteur * 9/10) ;
}
/ * Cette fonction permet de zoomer dans l’axe des abscisses des données
* Il s’exécute en arrière-plan et avis quand vous appuyez sur la touche droite
* Zoom avec pressage "+"
* Effectuer un zoom arrière en appuyant sur "-" * /
Sub keyReleased()
{
commutateur (clé)
{
cas « + » :
zoom * = 2.0f ;
println(zoom) ;
Si ((int) (largeur / zoom) < = 1)
zoom / = 2.0f ;
rupture ;
cas '-' :
zoom / = 2.0f ;
Si (zoom < 1.0F)
zoom * = 2.0f ;
rupture ;
}
}
/ * Ceci est la fonction principale qui appelle les autres fonctions
* Cette fonction s’exécute en continu * /
void draw()
{
Background(1) ; / * Définit l’arrière-plan de la fenêtre * /
drawGrid() ; / * Dessine la grille dans la fenêtre * /
Val = getData() ; / * Lit les données des trois chaînes, telles qu’envoyées par l’arduino dans un tableau * /
Si (val [0]! = -1) / * si les données sont dans la première chaîne, puis exercer de fonction * /
{
pushValue(val) ; / * Exécute un push de données descend d’une position et ajoute un nouveau point de données * /
}
drawLines() ; / * Ajouter le jeu de données suivant dans la fenêtre * /
Si (mousePressed) / * effectuer d’action lorsque vous appuyez sur le bouton de la souris * /
{
Save("/YourPathHere/OsciData1.png") ; / * enregistrer la capture d’écran de la fenêtre de données, mais attention image sera remplacé par le deuxième clic de la souris * /
}
}
Code de traitement de 3 canaux :
/*
* Oscilloscope
* Donne un rendu visuel de trois broches analogiques en temps réel.
*
* Ce logiciel développe le volume de canal d’une version antérieure.
* La version précédente était un projet qui fait partie du projet Accrochages
* Voir http://accrochages.drone.ws
*
* L’auteur de ce logiciel adapté n’a aucune relation d’Accrochages.
* Il les remercie pour le grand modèle et l’inspiration d’écrire ce logiciel.
*
* La déclaration suivante faisait partie du logiciel original.
* C’est pour votre information.
*
* (c) 2008 Sofian Audry (info
*
* Ce programme est un logiciel libre : vous pouvez le redistribuer et/ou le modifier
* elle aux termes de la GNU General Public License telle que publiée par
* la Free Software Foundation, soit la version 3 de la licence, ou
* (à votre choix) toute version ultérieure.
*
* Ce programme est distribué dans l’espoir qu’il sera utile,
* mais sans aucune garantie ; sans même la garantie implicite de
* Qualité marchande ou ADEQUATION a un usage particulier. Voir le
* GNU General Public License pour plus de détails.
*
* Vous devriez avoir reçu une copie de la GNU General Public License
* Parallèlement à ce programme. Si non, voir < http://www.gnu.org/licenses/>.
*/
Import processing.serial.* ;
Serial myPort ; / * Créer objet de série classe * /
EN-tête de char = « H » ; / * caractère pour identifier le début d’un message * /
court-LF = 10 ; / * Saut de ligne ASCII * /
portIndex court = 0 ; / * détermine l’USB port utilisé * /
int [] val = {-1, -1, -1} ; / * Variable utilisée pour la fonction de getY, 3 positions pour 3channels * /
int [] valuesCh1 ; / * Les trois variables contiendra les données de la fenêtre dans la mémoire, afin qu’ils peuvent être poussés et affiche * /
int [] valuesCh2 ;
int [] valuesCh3 ;
zoom du flotteur ; / * Définir « zoom » en tant que variable à virgule flottante * /
void setup()
{
Size(1014, 690) ; / * Ouvre une fenêtre de taille spécifique, taille maximum de mon écran d’ordinateur portable, retarder problèmes moitié par la fenêtre * /
taille (600, 400) ; / * plus petit écran = > inférieur à calculer = > aucun problème de retard * /
myPort = nouvelle série (ce, Serial.list() [portIndex], 9600) ; / * Ouvrir le port qui est connecter la platine et utilisent la même vitesse (9600bps) * /
valuesCh1 = new int [Largeur] ; / * Définir tableau avec autant d’éléments que x pixels dans la fenêtre, utilisée pour le traçage des données du canal 1 * /
valuesCh2 = new int [Largeur] ; / *... de canal2 * /
valuesCh3 = new int [Largeur] ; / *... de canal3 * /
Zoom = 1.0f ; / * Début avec 1 x facteur de zoom * /
Smooth() ; / * Dessiner des images avec des bords lisses * /
}
/ * Cette fonction convertit une valeur de données de canal en pixels illustrés de
* Sommet du graphe (qui est la position 0)
* Cette fonction retourne une valeur entière * /
int getY(int val)
{
Return (int) (hauteur - val/1023.0f * (hauteur - 1)) ;
}
/ * Fonction qui lit la chaîne de série de données qui ont été envoyées par l’arduino
* Met un tableau avec les trois valeurs de l’arduino
* Fonction est appelée en fonction du tirage au sort * /
int [] getData()
{
int [] ChValues = {-1, -1, -1} ; / * Définir tableau pour cette fonction * /
Message de chaîne = myPort.readStringUntil(LF) ; / * Lire dans la chaîne de données série envoyée par arduino * /
Si (message! = null) / * cela uniquement lorsque la réception d’un message complet valide * /
{
String [] data = message.split(",") ; / * Diviser le message séparées par des virgules en ses segments * /
if(Data[0].charAt(0) == en-tête) / * cocher caractère d’en-tête dans le premier champ, toujours vrai pour le message complet * /
{
pour (int i = 1; j’ai < data.length-1; i ++) / * ignorer l’en-tête et résilier cr et lf = > oeil seulement sur les points de trois données * /
{
ChValues [i-1] = Integer.parseInt(data[i]) ; / * Écrire les données des canaux en tableau, je suis passé de données au tableau 1 en raison d’en-tête * /
}
}
}
Return ChValues ; / * Retourne un tableau ChValues qui contient les données des canaux * /
}
/ * Cette fonction pousse tous les points de données du une poste fenêtre vers la gauche, puis on ajoute le point de données qui a été lu juste * /
« PushValue » Sub (int [] value)
{
pour (int i = 0; i < largeur-1; i ++)
{
valuesCh1 [i] = valuesCh1 [i + 1] ; / * Déplace les données point par position * /
valuesCh2 [i] = valuesCh2 [i + 1] ;
valuesCh3 [i] = valuesCh3 [i + 1] ;
}
valuesCh1 [largeur-1] = valeur [0] ; / * Ajouter point de données * /
valuesCh2 [largeur-1] = valeur [1] ;
valuesCh3 [largeur-1] = valeur [2] ;
}
/ * Cette fonction dessine les données dans la fenêtre * /
Sub drawLines()
{
int displayWidth = (int) (largeur / zoom) ; / * Calcule la largeur de la fenêtre, compte tenu de la x-change si un zoom a la valeur * /
int k = valuesCh1.length - displayWidth ; / * Cela calcule la position vers le haut à laquelle sont indiqués les points de données * /
int x0 = 0 ; / * x valeur, très à gauche de la fenêtre (= 0) est affecté à x0 et utilisé pour tous les canaux * /
int ya0 = getY(valuesCh1[k]) ; / * valeur y du dernier point indiqué est affectée à ya0 pour le canal 1 * /
yb0 int = getY(valuesCh2[k]) ; / * valeur y du dernier point indiqué est affectée à yb0 pour canal2 * /
int yc0 = getY(valuesCh3[k]) ; / * valeur y du dernier point indiqué est affectée à yc0 pour canal3 * /
pour (int i = 1; j’ai < displayWidth-1; i ++) / * boucle qui s’étend du point k au très droite de la fenêtre * /
{
k ++ ; / * Incrémentation k pour le prochain point de données * /
int x1 = (int) (j’ai * (largeur-1) / (displayWidth-1)) ; / * Calculer suivant x valeur * /
ya1 int = getY(valuesCh1[k]) ; / * Get prochaine valeur y pour canal 1 * /
yb1 int = getY(valuesCh2[k]) ; / * Obtenir la prochaine valeur y pour canal2 * /
yc1 int = getY(valuesCh3[k]) ; / * Obtenir la prochaine valeur y pour canal3 * /
strokeWeight(2) ; / * Dessiner des lignes plus épaisses * /
accident vasculaire cérébral (255, 0, 0) ; / * Dessiner une ligne rouge pour canal 1 * /
ligne (x0, ya0, x1, ya1) ; / * Tracer un segment de ligne pour canal 1 * /
accident vasculaire cérébral (0, 255, 0) ; / * Dessiner une ligne verte pour canal2 * /
ligne (x0, yb0, x1, yb1) ; / * Tracer un segment de ligne pour canal2 * /
accident vasculaire cérébral (0, 0, 255) ; / * Dessiner une ligne bleue pour canal3 * /
ligne (x0, yc0, x1, yc1) ; / * Tracer un segment de ligne pour canal3 * /
x0 = x1 ; / * Maj x valeur pour calculer des segments de ligne suivante * /
ya0 = ya1 ; / * Changer les valeur y pour 1 afin de calculer des segments de ligne suivante * /
YB0 = yb1 ; / * Changer les valeur y pour canal2 calculer des segments de ligne suivante * /
yc0 = yc1 ; / * Changer les valeur y canal3 calculer des segments de ligne suivante * /
}
}
/ * Cette fonction dessine des lignes de la grille dans la fenêtre
* J’ai espacé les lignes afin qu’elles représentent des étapes 10 % et 20 % en 2 couleurs différentes
Pour les signaux de 5V max, c’est pas 0.5 & 1.0V * /
Sub drawGrid()
{
accident vasculaire cérébral (150, 150, 0) ;
ligne (0, hauteur/5, width, height/5) ;
ligne (hauteur 0, * 2/5, largeur, hauteur * 2/5) ;
ligne (hauteur 0, * 3/5, largeur, hauteur * 3/5) ;
ligne (hauteur 0, * 4/5, largeur, hauteur * 4/5) ;
accident vasculaire cérébral (150, 150, 150) ;
ligne (0, hauteur/10, largeur, hauteur/10) ;
ligne (hauteur 0, * 3/10, largeur, hauteur * 3/10) ;
ligne (hauteur 0, * 5/10, largeur, hauteur * 5/10) ;
ligne (hauteur 0, * 7/10, largeur, hauteur * 7/10) ;
ligne (hauteur 0, * 9/10, largeur, hauteur * 9/10) ;
}
/ * Cette fonction permet de zoomer dans l’axe des abscisses des données
* Il s’exécute en arrière-plan et avis quand vous appuyez sur la touche droite
* Zoom avec pressage "+"
* Effectuer un zoom arrière en appuyant sur "-" * /
Sub keyReleased()
{
commutateur (clé)
{
cas « + » :
zoom * = 2.0f ;
println(zoom) ;
Si ((int) (largeur / zoom) < = 1)
zoom / = 2.0f ;
rupture ;
cas '-' :
zoom / = 2.0f ;
Si (zoom < 1.0F)
zoom * = 2.0f ;
rupture ;
}
}
/ * Ceci est la fonction principale qui appelle les autres fonctions
* Cette fonction s’exécute en continu * /
void draw()
{
Background(1) ; / * Définit l’arrière-plan de la fenêtre * /
drawGrid() ; / * Dessine la grille dans la fenêtre * /
Val = getData() ; / * Lit les données des trois chaînes, telles qu’envoyées par l’arduino dans un tableau * /
Si (val [0]! = -1) / * si les données sont dans la première chaîne, puis exercer de fonction * /
{
pushValue(val) ; / * Exécute un push de données descend d’une position et ajoute un nouveau point de données * /
}
drawLines() ; / * Ajouter le jeu de données suivant dans la fenêtre * /
Si (mousePressed) / * effectuer d’action lorsque vous appuyez sur le bouton de la souris * /
{
Save("/YourPathHere/OsciData1.png") ; / * enregistrer la capture d’écran de la fenêtre de données, mais attention image sera remplacé par le deuxième clic de la souris * /
}
}
