Archives de l’auteur : Hervé Mazelin

Arduino Le traceur série

Mise à jour le 20/09/2020 : Le traceur série nous permet d’afficher une ou plusieurs courbes en même temps façon oscilloscope.Nous apprendrons aussi à réaliser un chronogramme temporel en créant un offset

Continuer la lecture →

Filaflex – F000083

Le bq Filaflex est un filament élastique qui permet de créer des pièces élastiques par impression 3D, sans avoir à modifier l’imprimante. Ce matériau révolutionnaire est un élastomère thermoplastique (TPE), composé d’une base en polyuréthane avec des additifs pour le rendre imprimable dans une imprimante 3D.

Caractéristiques techniques :

• 1,75 mm disponible
• Tolérance de +/-0,08 mm
• Température d’impression : 220 – 260 °C
• Vitesse d’impression : 30 – 50 mm/s
• Modules résistants à la traction : 95 MPa
• Adhérence élevée avec lit conçu par impression 3D
• Base de lit chauffant non nécessaire
• Ruban Kapton non nécessaire
• Nul besoin d’aérosol à adhérence spécial
• Sans odeur
• Résistant à l’acétone, aux carburants et aux solvants
• Taille de bobine : 133 x 55 mm

Le filament élastique FilaFlex est entièrement compatible avec les imprimantes BQ Witbox 2 et Hephestos Prusa.

Hotend température	212-230	Celsius
Bed température	0	Celsius
Print speed	15-40	mm/s
Rétraction distance	3,5-3,9	mm
Rétraction speed	40	mm/s
Z-Hop	0-0,08	mm
Layer height	0,1-0,25	mm

Raspberry Pi3 b

Mise à jour le 09/01/2020 :Le Raspberry Pi3 est de 50 à 60 % plus performante que la carte de deuxième génération.Le Raspberry Pi3 B est un ordinateur monocarte pouvant se connecter à un téléviseur et à un clavier. Il dispose d’une connectivité WiFi et Bluetooth. Il se boote depuis la carte micro-SD et fonctionne sous OS Linux ou Windows 10 IoT.

Continuer la lecture →

Carte microcontroleur pour système embarqué

Mise à jour le 07/01/2020 : Dans cet article vous trouverez une partie des cartes microcontroleur pour système embarqué que RedOhm utilise pour ses applications , avec la documentation , les schémas , les programmes

Choisissez votre type de cartes

Carte Arduino

Arduino est une plate-forme électronique open-source composée de matériel et logiciel. Chaque aspect est conçu pour être simple, de sorte que vous puissiez apprendre à coder et à concevoir un projet rapidement et en toute simplicité.


Arduino Nano		Arduino UNO		Arduino Uno WiFi


Arduino Uno WIFI REV2		Arduino Yun 2		Arduino Mega

Carte chipKIT

La Plateforme compatible Arduino chipKIT uC32 est basée sur la populaire plateforme de prototypage en open source physique d’Arduino et y ajoute les performances du microcontrôleur Microchip PIC32.


ChipKIT Wi-FIRE

Cartes Teensy

Le Teensy est un système complet de développement de microcontrôleurs basé sur USB, dans un très faible encombrement, capable de mettre en œuvre de nombreux types de projets . Toute la programmation se fait via le port USB.


Teensy 3.2

Carte Raspberry Pi

Cette carte est destinée à encourager l’apprentissage de la programmation informatique ; elle permet l’exécution de plusieurs variantes de système d’exploitation libre GNU/Linux, notamment Debian, et des logiciels compatibles. Elle fonctionne également avec le système d’exploitation Microsoft Windows : Windows 10 IoT Core³ et celui de Google, Android Pi.


Raspberry Pi 3 B 1 GB		Raspberry Pi 3 B +		Raspberry Pi 4 B – 4 GB

CARTES LATTEPANDA

La carte de développement LattePanda est un ordinateur monocarte compatible Arduino, fonctionnant sous Windows 10 ou Linux.
Ces cartes embarquent également un ATMega32u4 compatible Arduino Leonardo se programmant directement à partir de Windows via le logiciel Arduino.


LattePanda DFR0418		Alpha 800s 8 GB DFR0545

CARTES ArbotiX-M

ArbotiX-M est au cœur de chaque robot Interbotix. Ce contrôleur de robot polyvalent est une solution de contrôle avancée pour les actionneurs basés sur BIOLOID et DYNAMIXEL mais pas que . En tant que microcontrôleur compatible Arduino, l’Arbotix bénéficie également d’une énorme communauté open source de bibliothèques et d’exemples.

ArbotiX-M

Capteur de flexion

Mise à jour le 28/12/2019 :

Sommaire :

Capteur Flexible unidirectionnel de type Flex Sensor
- Application des capteurs Flex Sensor
- Spécifications mécaniques
- Spécifications électriques
Application du capteur unidirectionnel
Definition d’un capteur Flexible bidirectionnel
Notes et références sur les capteurs de flexion

Definition d’un capteur Flexible unidirectionnel
de type Flex Sensor

Un côté du capteur est imprimé avec une encre polymère qui contient des particules conductrices. Lorsque le capteur est droit, les particules confèrent à l’encre une résistance d’environ 30k Ohms. Lorsque le capteur est plié à l’écart de l’encre, les particules conductrices s’éloignent davantage, augmentant cette résistance (à environ 50k-70K Ohms lorsque le capteur est plié à 90 ( principe de fonctionnement du capteur SEN-10264 en 2.2 pouce et le SEN-08606 en 4.5 pouce)

Capteur de flexion : Flex Sensor 2-2

Ce capteur flexible est une résistance variable pas comme les autres. La résistance du capteur de flexion augmente à mesure que le corps du composant se plie.

Les capteurs Flex sont disponibles en deux tailles: une de 2,2 « (5,588 cm) de long et une autre de 4,5 » (11,43 cm) de long .

Laissés à plat, ces capteurs ressembleront à une résistance de 30 kΩ. En se pliant, la résistance entre les deux bornes augmentera jusqu’à 70kΩ à un angle de 90 °..

Capteur de flexion : Flex Sensor 4-5

En combinant le capteur flexible avec une résistance statique pour créer un diviseur de tension , vous pouvez produire une tension variable qui peut être lue par le convertisseur analogique-numérique d’un microcontrôleur.

Application des capteurs Flex Sensor

Robotique
Jeux (Virtual Motion)
Équipement médical
Périphériques d’ordinateur
Instruments de musique
Thérapie physique

Spécifications mécaniques du Flex Sensor

Cycle de vie : > 1 million
Epaisseur : 0,43 mm (0,017 « )
Plage de température : -35 ° C à + 80 ° C

Spécifications électriques du capteur Flex Sensor

Résistance à plat : 10K Ohms ± 30%
Résistance à la flexion : minimum 2 fois supérieure à la résistance à plat à 180 ° de pincement.
Puissance nominale : 0,5 watts en continu; 1 Watt de pointe

Retour au sommaire

Application du capteur unidirectionnel

.

Retour au sommaire

Definition d’un capteur Flexible Bidirectionnel

Le Capteur Flexible Bidirectionnel est constitué d’un substrat revêtu, tel que le plastique, dont la conductivité électrique est modifiée lorsqu’il se plie. Les systèmes électroniques se connectent au capteur et mesure de manière précise la quantité de flexion ou de mouvement qui se produit. La conception de la couche unique du capteur flexible élimine la plupart des problèmes associés aux capteurs classiques, tels que la poussière, la saleté, les liquides ainsi que les effets de la chaleur et de la pression. Les surlaminés ou le surmoulage peuvent également être appliqués aux capteurs pour augmenter leur protection contre l’environnement.

Permet de mesurer le mouvement mécanique, le débit d’air, le débit d’eau et même les vibrations.
Peut être utilisé comme capteur de mouvement ou comme interrupteur très résistant et très fiable.
Ne comporte aucune pièce mobile et est complètement silencieux en fonctionnement

Retour au sommaire

Notes et références sur les capteurs de flexion

Fournisseur :

https://www.robotshop.com
https://learn.sparkfun.com

Information technique :

sparkfun pour le capteur unidirectionnel
spectrasymbol.com pour les capteurs de type FS2L095

en cours de réalisation

Retour au sommaire

Création d’un indexeur pour la plateforme lidar

Mise à jour le 22/12/2019 : Dans cet article ,nous allons étudier comment installer, câbler, programmer un capteur de position pour cela , nous allons détourner le fonctionnement du module compteur de vitesse ECC 03

Continuer la lecture →

Modification electronique de l’avant bras de Maya

Mise à jour le 28/12/2019 : Dans cette page nous allons étudier la modification de l’avant-bras qui a pour but de supprimer les fils qui partent du torse de Maya et qui parcourt les bras du robot. La solution retenue est l’utilisation du contrôleur de robot EZ-B IoTiny.

Continuer la lecture →

Création d’un cercle point par point sur Processing

Sommaire :

Rappel de l’utilisation de quelques fonctions de Processing
- width
- height
- vertex
- random()
Etape 3.1 : Traçage d’un cercle point par point
Etape 3.2 : Création d’une variable modifiant les valeurs de rayon.
Etape 3.3 : Création d’un cercle point par point avec déplacement .
Pour tout problème
Retour au menu construction d’une tourelle pour laser lidar

A suivre cet article est mis à jour régulièrement

Rappel de l’utilisation de quelques fonctions de Processing.

width :

Variable système qui stocke la largeur de la fenêtre d’affichage. Cette valeur est définie par le premier paramètre de la fonction size () . Par exemple, la fonction size (320, 240) définit la variable width sur la valeur 320. La valeur par défaut de width est 100 si la taille () n’est pas utilisée dans un programme.

height

:Variable système qui stocke la hauteur de la fenêtre d’affichage. Cette valeur est définie par le deuxième paramètre de la fonction size () . Par exemple, la fonction size (320, 240) définit la variable height sur 240. La valeur par défaut de height est 100 si la taille () n’est pas utilisée dans un programme.

vertex :

Toutes les formes sont construites en connectant une série de sommets. vertex () est utilisé pour spécifier les coordonnées de sommet pour les points, les lignes, les triangles, les quads et les polygones. Il est utilisé exclusivement dans les fonctions beginShape () et endShape () .

Pour dessiner un sommet en 3D à l’aide du paramètre z , vous devez associer le paramètre P3D à la taille, comme illustré dans l’exemple ci-dessous.

//
//
// Dessiner des sommets en 3D nécessite P3D
// comme paramètre pour size ()
size(100, 100, P3D);
beginShape(POINTS);
vertex(30, 20, -50);
vertex(85, 20, -50);
vertex(85, 75, -50);
vertex(30, 75, -50);
endShape();

// Dessiner des sommets en 3D nécessite P3D

// comme paramètre pour size ()

size(100, 100, P3D);

beginShape(POINTS);

vertex(30, 20, -50);

vertex(85, 20, -50);

vertex(85, 75, -50);

vertex(30, 75, -50);

endShape();

random()

Génère des nombres aléatoires. Chaque fois que la fonction random () est appelée, elle renvoie une valeur inattendue dans la plage spécifiée. Si un seul paramètre est passé à la fonction, il retournera un float compris entre zéro et la valeur du paramètre haut . Par exemple, random (5) renvoie des valeurs comprises entre 0 et 5 (commençant à zéro et pouvant aller jusqu’à 5).

Si deux paramètres sont spécifiés, la fonction renvoie un float avec une valeur comprise entre les deux valeurs. Par exemple, random (-5, 10.2) renvoie des valeurs allant de -5 à 10.2 maximum (sans l’inclure). Pour convertir un nombre aléatoire à virgule flottante en entier, utilisez la fonction int () .

Syntax :

random ( limite supérieure )
random ( limite inferieure , limite supérieure )

Retour au sommaire

Etape 3.1 traçage d’un cercle point par point

A savoir : processing travaille en radians par defaut

Le but de ce programme est de pouvoir dessiner un cercle non pas avec la commande circle() , mais en utilisant la commande vertex pour pouvoir tracer la circonférence du cercle point par point .

Le but est bien sûr de pouvoir utiliser ce code pour la mise en application d’un laser rotatif afin de retracer sur un écran l’ensemble des obstacles qui l’entourent. On pourra évidemment utiliser ce code aussi bien pour une rotation complète soit 360° ou bien des angles personnalisés du type 180° .

Le rayon du cercle est défini à la ligne 75 , vous pouvez donner comme valeur numérique à rayon la valeur qui vous convient.

Le calcul des coordonnées en X et Y se définisse en ligne 79 et 80

//
//
//*********************************************************************
//*                                                                   *
//* Programme permettant de mieux comprendre le fonctionnement de la  *
//* visualisation sur l’écran des différentes lectures du             *
//* laser lidar ( simulation de déplacement )                         * 
//*                                                                   *
//* RedOhm                                                            *
//* Programme : H-Mazelin                                             *
//* Le 09-11-2019                                                     *
//*                                                                   *
//* Version de IDE Processing 3.5.3                                   *
//* Nom du programme :                                                * 
//* Etape_3_1_etude_de_la_visualisation_en_2D_sur_l_ecran_du_pc       *
//* Notre site : https://www.redohm.fr                                *
//*                                                                   *
//*********************************************************************



// 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 (600, 600);
  // choix de la couleur du fond de la fenetre 
  // syntaxe : background (rouge,vert,bleu )
  // valeur du rouge de 0 à 255 idem pour les autres couleurs
  // affichage du fond en blanc
  background (255);
  
  // L'utilisation des fonctions beginShape () et endShape () permet de
// créer des formulaires plus complexes. beginShape () commence à 
// enregistrer les sommets d'une forme et endShape () arrête l'enregistrement  

beginShape();
 
 // boucle simulant la rotation de mon laser lidar soit 360°
 // on peut le modifier pour une demie rotation soit 180°
 for(int i=0; i<360; i++) 
 
 {
  
// A savoir processing travaille en radians par defaut
   
// On declare la variable angle en nombre à virgule flottante
// virgule flottante = les nombres avec un point decimal 
// la valeur de la variable comporte le radians de la valeur de i
// soit : 1 × π/180 = 0,01745rad 
   float angle = radians(i);
 
 
// width = Variable système qui stocke la largeur de la fenêtre
// d'affichage. 
 float xCentre = width/2;
// Variable système qui stocke la hauteur de la fenêtre d'affichage. 
// Cette valeur est définie par le deuxième paramètre de la fonction size () 
 float yCentre = height/2;
 
 

// on declare la variable rayon en nombre à virgule flottante 
// et on ajoute la valeur du laser en simulation 
 float rayon = 120;
 
// on calcul les coordonnées de notre point en x et y 
// en tenant compte des angles 
 float xCoord = xCentre + sin(angle) * rayon ;
 float yCoord = yCentre + cos(angle) * rayon ;
 
// Toutes les formes sont construites en connectant une série de sommets.
// vertex () est utilisé pour spécifier les coordonnées de sommet pour
// les points, les lignes, les triangles, les quads et les polygones. Il
// est utilisé exclusivement dans les fonctions beginShape () et endShape () . 
 vertex(xCoord,yCoord );
   
}

// la fonction endShape () est le compagnon de beginShape () et ne
// peut être appelée qu'après beginShape () . Lorsque endShape () 
// est appelée, toutes les données d'image définies depuis l'appel
// précédent à beginShape () sont écrites dans le tampon d'image.
// La constante CLOSE comme valeur pour le paramètre MODE pour fermer la forme

endShape(CLOSE);

 
 
}



//Le programme principal s’exécute par une boucle infinie appelée draw () 
void draw ()

{
  


}

100

101

102

103

104

105

106

107

//*********************************************************************

//* *

//* Programme permettant de mieux comprendre le fonctionnement de la *

//* visualisation sur l’écran des différentes lectures du *

//* laser lidar ( simulation de déplacement ) *

//* *

//* RedOhm *

//* Programme : H-Mazelin *

//* Le 09-11-2019 *

//* *

//* Version de IDE Processing 3.5.3 *

//* Nom du programme : *

//* Etape_3_1_etude_de_la_visualisation_en_2D_sur_l_ecran_du_pc *

//* Notre site : https://www.redohm.fr *

//* *

//*********************************************************************

// 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 (600, 600);

// choix de la couleur du fond de la fenetre

// syntaxe : background (rouge,vert,bleu )

// valeur du rouge de 0 à 255 idem pour les autres couleurs

// affichage du fond en blanc

background (255);

// L'utilisation des fonctions beginShape () et endShape () permet de

// créer des formulaires plus complexes. beginShape () commence à

// enregistrer les sommets d'une forme et endShape () arrête l'enregistrement

beginShape();

// boucle simulant la rotation de mon laser lidar soit 360°

// on peut le modifier pour une demie rotation soit 180°

for(int i=0; i<360; i++)

{

// A savoir processing travaille en radians par defaut

// On declare la variable angle en nombre à virgule flottante

// virgule flottante = les nombres avec un point decimal

// la valeur de la variable comporte le radians de la valeur de i

// soit : 1 × π/180 = 0,01745rad

float angle = radians(i);

// width = Variable système qui stocke la largeur de la fenêtre

// d'affichage.

float xCentre = width/2;

// Variable système qui stocke la hauteur de la fenêtre d'affichage.

// Cette valeur est définie par le deuxième paramètre de la fonction size ()

float yCentre = height/2;

// on declare la variable rayon en nombre à virgule flottante

// et on ajoute la valeur du laser en simulation

float rayon = 120;

// on calcul les coordonnées de notre point en x et y

// en tenant compte des angles

float xCoord = xCentre + sin(angle) * rayon ;

float yCoord = yCentre + cos(angle) * rayon ;

// Toutes les formes sont construites en connectant une série de sommets.

// vertex () est utilisé pour spécifier les coordonnées de sommet pour

// les points, les lignes, les triangles, les quads et les polygones. Il

// est utilisé exclusivement dans les fonctions beginShape () et endShape () .

vertex(xCoord,yCoord );

}

// la fonction endShape () est le compagnon de beginShape () et ne

// peut être appelée qu'après beginShape () . Lorsque endShape ()

// est appelée, toutes les données d'image définies depuis l'appel

// précédent à beginShape () sont écrites dans le tampon d'image.

// La constante CLOSE comme valeur pour le paramètre MODE pour fermer la forme

endShape(CLOSE);

}

//Le programme principal s’exécute par une boucle infinie appelée draw ()

void draw ()

{

}

Retour au sommaire

Etape 3.2 Création d’une variable modifiant les valeurs de rayon.

Le but à atteindre dans cette étape est de tracer un cercle point par point et chaque point possédant un rayon différent. Pour cela nous utilisons un générateur de nombres aléatoires qui sera paramétré de la façon suivante , rayon mini 100, rayon maxi 160. La valeur aléatoire s’ajoutera à un rayon fixe que l’on s’est donné. Le résultat de ce calcul étant la figure à 360 degrés située ci-dessous.

Bien évidemment , pour l’application sur le laser nous supprimons le générateur de nombres aléatoires par la mesure prise par le laser remis à l’échelle pour dessiner les obstacles se situant dans le rayon du laser.

//
//
//*********************************************************************
//*                                                                   *
//* Programme permettant de mieux comprendre le fonctionnement de la  *
//* visualisation sur l’écran des différentes lectures du             *
//* laser lidar ( simulation de déplacement )                         * 
//*                                                                   *
//* RedOhm                                                            *
//* Programme : H-Mazelin                                             *
//* Le 09-11-2019                                                     *
//*                                                                   *
//* Version de IDE Processing 3.5.3                                   *
//* Nom du programme :                                                * 
//* Etape_3_2_etude_de_la_visualisation_en_2D_sur_l_ecran_du_pc       *
//* Notre site : https://www.redohm.fr                                *
//*                                                                   *
//*********************************************************************



// 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 (600, 600);
  // choix de la couleur du fond de la fenetre 
  // syntaxe : background (rouge,vert,bleu )
  // valeur du rouge de 0 à 255 idem pour les autres couleurs
  // affichage du fond en blanc
  background (255);
  
  // L'utilisation des fonctions beginShape () et endShape () permet de
// créer des formulaires plus complexes. beginShape () commence à 
// enregistrer les sommets d'une forme et endShape () arrête l'enregistrement  

beginShape();
  
 // boucle simulant la rotation de mon laser lidar soit 360°
 // on peut le modifier pour une demie rotation soit 180°
 for(int i=0; i<360; i++) 
 
 {
  
// A savoir processing travaille en radians par defaut


   
// On declare la variable angle en nombre à virgule flottante
// virgule flottante = les nombres avec un point decimal 
// la valeur de la variable comporte le radians de la valeur de i
// soit : 1 × π/180 = 0,01745rad 
   float angle = radians(i);
 
 
// width = Variable système qui stocke la largeur de la fenêtre
// d'affichage. 
 float xCentre = width/2;
// Variable système qui stocke la hauteur de la fenêtre d'affichage. 
// Cette valeur est définie par le deuxième paramètre de la fonction size () 
 float yCentre = height/2;
 
 
// Génère des nombres aléatoires. Chaque fois que la fonction random ()
// est appelée, elle renvoie une valeur inattendue dans la plage
// spécifiée 
 float laser = random(100,150);
 

// on declare la variable rayon en nombre à virgule flottante 
// et on ajoute la valeur du laser en simulation 
 float rayon = 50+laser;
 
// on calcul les coordonnées de notre point en x et y 
// en tenant compte des angles 
 float xCoord = xCentre + sin(angle) * rayon ;
 float yCoord = yCentre + cos(angle) * rayon ;
 
// Toutes les formes sont construites en connectant une série de sommets.
// vertex () est utilisé pour spécifier les coordonnées de sommet pour
// les points, les lignes, les triangles, les quads et les polygones. Il
// est utilisé exclusivement dans les fonctions beginShape () et endShape () . 
 vertex(xCoord,yCoord );
 
  
  
  
}

// la fonction endShape () est le compagnon de beginShape () et ne
// peut être appelée qu'après beginShape () . Lorsque endShape () 
// est appelée, toutes les données d'image définies depuis l'appel
// précédent à beginShape () sont écrites dans le tampon d'image.
// La constante CLOSE comme valeur pour le paramètre MODE pour fermer la forme

endShape(CLOSE);

 
 
}



//Le programme principal s’exécute par une boucle infinie appelée draw () 
void draw ()

{
  


}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

//*********************************************************************

//* *

//* Programme permettant de mieux comprendre le fonctionnement de la *

//* visualisation sur l’écran des différentes lectures du *

//* laser lidar ( simulation de déplacement ) *

//* *

//* RedOhm *

//* Programme : H-Mazelin *

//* Le 09-11-2019 *

//* *

//* Version de IDE Processing 3.5.3 *

//* Nom du programme : *

//* Etape_3_2_etude_de_la_visualisation_en_2D_sur_l_ecran_du_pc *

//* Notre site : https://www.redohm.fr *

//* *

//*********************************************************************

// 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 (600, 600);

// choix de la couleur du fond de la fenetre

// syntaxe : background (rouge,vert,bleu )

// valeur du rouge de 0 à 255 idem pour les autres couleurs

// affichage du fond en blanc

background (255);

// L'utilisation des fonctions beginShape () et endShape () permet de

// créer des formulaires plus complexes. beginShape () commence à

// enregistrer les sommets d'une forme et endShape () arrête l'enregistrement

beginShape();

// boucle simulant la rotation de mon laser lidar soit 360°

// on peut le modifier pour une demie rotation soit 180°

for(int i=0; i<360; i++)

{

// A savoir processing travaille en radians par defaut

// On declare la variable angle en nombre à virgule flottante

// virgule flottante = les nombres avec un point decimal

// la valeur de la variable comporte le radians de la valeur de i

// soit : 1 × π/180 = 0,01745rad

float angle = radians(i);

// width = Variable système qui stocke la largeur de la fenêtre

// d'affichage.

float xCentre = width/2;

// Variable système qui stocke la hauteur de la fenêtre d'affichage.

// Cette valeur est définie par le deuxième paramètre de la fonction size ()

float yCentre = height/2;

// Génère des nombres aléatoires. Chaque fois que la fonction random ()

// est appelée, elle renvoie une valeur inattendue dans la plage

// spécifiée

float laser = random(100,150);

// on declare la variable rayon en nombre à virgule flottante

// et on ajoute la valeur du laser en simulation

float rayon = 50+laser;

// on calcul les coordonnées de notre point en x et y

// en tenant compte des angles

float xCoord = xCentre + sin(angle) * rayon ;

float yCoord = yCentre + cos(angle) * rayon ;

// Toutes les formes sont construites en connectant une série de sommets.

// vertex () est utilisé pour spécifier les coordonnées de sommet pour

// les points, les lignes, les triangles, les quads et les polygones. Il

// est utilisé exclusivement dans les fonctions beginShape () et endShape () .

vertex(xCoord,yCoord );

}

// la fonction endShape () est le compagnon de beginShape () et ne

// peut être appelée qu'après beginShape () . Lorsque endShape ()

// est appelée, toutes les données d'image définies depuis l'appel

// précédent à beginShape () sont écrites dans le tampon d'image.

// La constante CLOSE comme valeur pour le paramètre MODE pour fermer la forme

endShape(CLOSE);

}

//Le programme principal s’exécute par une boucle infinie appelée draw ()

void draw ()

{

}

Retour au sommaire

Etape 3.3 Création d’un cercle point par point avec déplacement .

Les modifications suivante :

Déclaration de la variable pour simuler le déplacement du laser en X .Variable Xdepla
Incrémentation de la variable Xdepla. Xdepla ++
Création d’une ligne de code pour effectuer ou simuler le déplacement d’un éventuel robot mobile . ( voir ci-dessous )
L’ensemble du code pour la création du cercle migre dans la fonction void draw

//
//
// activer la ligne de code ci-dessous pour lancer le deplacement 
 float xCentre = 300+Xdepla ;

// activer la ligne de code ci-dessous pour lancer le deplacement

float xCentre = 300+Xdepla ;

Vous pouvez copier le programme en sélectionnant l’ensemble puis contrôle C ou suivez les informations dans la barre supérieure du code

//
//
//*********************************************************************
//*                                                                   *
//* Programme permettant de mieux comprendre le fonctionnement de la  *
//* visualisation sur l’écran des différentes lectures du             *
//* laser lidar ( simulation de déplacement )                         * 
//*                                                                   *
//* RedOhm                                                            *
//* Programme : H-Mazelin                                             *
//* Le 09-11-2019                                                     *
//*                                                                   *
//* Version de IDE Processing 3.5.3                                   *
//* Nom du programme :                                                * 
//* Etape_3_3_etude_de_la_visualisation_en_2D_sur_l_ecran_du_pc       *
//* Notre site : https://www.redohm.fr                                *
//*                                                                   *
//*********************************************************************




// je declare ma variable pour simuler mon deplacement en x
float Xdepla;



// 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 (600, 600);
  // choix de la couleur du fond de la fenetre 
  // syntaxe : background (rouge,vert,bleu )
  // valeur du rouge de 0 à 255 idem pour les autres couleurs
  // affichage du fond en blanc
  background (255);
  
 
}



//Le programme principal s’exécute par une boucle infinie appelée draw () 
void draw ()

{
  
// L'utilisation des fonctions beginShape () et endShape () permet de
// créer des formulaires plus complexes. beginShape () commence à 
// enregistrer les sommets d'une forme et endShape () arrête l'enregistrement  

beginShape();

 // incrementation de mon deplacement en x pour simuler un robot 
 // mobile 
 // cette fonction est egale à Xdepla = Xdepla +1
 Xdepla ++ ;
 
 
 // Efface mon ecran pour ne voir qu'un tracé 
 background(255);
 
 
 // boucle simulant la rotation de mon laser lidar soit 360°
 // on peut le modifier pour une demie rotation soit 180°
 for(int i=0; i<360; i++) 
 
 {
  
// A savoir processing travaille en radians par defaut


   
// On declare la variable angle en nombre à virgule flottante
// virgule flottante = les nombres avec un point decimal 
// la valeur de la variable comporte le radians de la valeur de i
// soit : 1 × π/180 = 0,01745rad 
   float angle = radians(i);
 
 
// activer la ligne de code ci-dessous pour lancer le deplacement 
 float xCentre = 300+Xdepla ;
 
// float xCentre = width/2;
 float yCentre = height/2;
 
// Génère des nombres aléatoires. Chaque fois que la fonction random ()
// est appelée, elle renvoie une valeur inattendue dans la plage
// spécifiée 
 float laser = random(100,150);
 

// on declare la variable rayon en nombre à virgule flottante 
// et on ajoute la valeur du laser en simulation 
 float rayon = 50+laser;
 
// on calcul les coordonnées de notre point en x et y 
// en tenant compte des angles 
 float xCoord = xCentre + sin(angle) * rayon ;
 float yCoord = yCentre + cos(angle) * rayon ;
 
// Toutes les formes sont construites en connectant une série de sommets.
// vertex () est utilisé pour spécifier les coordonnées de sommet pour
// les points, les lignes, les triangles, les quads et les polygones. Il
// est utilisé exclusivement dans les fonctions beginShape () et endShape () . 
 vertex(xCoord,yCoord );
 
  
  
  
}

// la fonction endShape () est le compagnon de beginShape () et ne
// peut être appelée qu'après beginShape () . Lorsque endShape () 
// est appelée, toutes les données d'image définies depuis l'appel
// précédent à beginShape () sont écrites dans le tampon d'image.
// La constante CLOSE comme valeur pour le paramètre MODE pour fermer la forme

endShape(CLOSE);



}

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

//*********************************************************************

//* *

//* Programme permettant de mieux comprendre le fonctionnement de la *

//* visualisation sur l’écran des différentes lectures du *

//* laser lidar ( simulation de déplacement ) *

//* *

//* RedOhm *

//* Programme : H-Mazelin *

//* Le 09-11-2019 *

//* *

//* Version de IDE Processing 3.5.3 *

//* Nom du programme : *

//* Etape_3_3_etude_de_la_visualisation_en_2D_sur_l_ecran_du_pc *

//* Notre site : https://www.redohm.fr *

//* *

//*********************************************************************

// je declare ma variable pour simuler mon deplacement en x

float Xdepla;

// 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 (600, 600);

// choix de la couleur du fond de la fenetre

// syntaxe : background (rouge,vert,bleu )

// valeur du rouge de 0 à 255 idem pour les autres couleurs

// affichage du fond en blanc

background (255);

}

//Le programme principal s’exécute par une boucle infinie appelée draw ()

void draw ()

{

// L'utilisation des fonctions beginShape () et endShape () permet de

// créer des formulaires plus complexes. beginShape () commence à

// enregistrer les sommets d'une forme et endShape () arrête l'enregistrement

beginShape();

// incrementation de mon deplacement en x pour simuler un robot

// mobile

// cette fonction est egale à Xdepla = Xdepla +1

Xdepla ++ ;

// Efface mon ecran pour ne voir qu'un tracé

background(255);

// boucle simulant la rotation de mon laser lidar soit 360°

// on peut le modifier pour une demie rotation soit 180°

for(int i=0; i<360; i++)

{

// A savoir processing travaille en radians par defaut

// On declare la variable angle en nombre à virgule flottante

// virgule flottante = les nombres avec un point decimal

// la valeur de la variable comporte le radians de la valeur de i

// soit : 1 × π/180 = 0,01745rad

float angle = radians(i);

// activer la ligne de code ci-dessous pour lancer le deplacement

float xCentre = 300+Xdepla ;

// float xCentre = width/2;

float yCentre = height/2;

// Génère des nombres aléatoires. Chaque fois que la fonction random ()

// est appelée, elle renvoie une valeur inattendue dans la plage

// spécifiée

float laser = random(100,150);

// on declare la variable rayon en nombre à virgule flottante

// et on ajoute la valeur du laser en simulation

float rayon = 50+laser;

// on calcul les coordonnées de notre point en x et y

// en tenant compte des angles

float xCoord = xCentre + sin(angle) * rayon ;

float yCoord = yCentre + cos(angle) * rayon ;

// Toutes les formes sont construites en connectant une série de sommets.

// vertex () est utilisé pour spécifier les coordonnées de sommet pour

// les points, les lignes, les triangles, les quads et les polygones. Il

// est utilisé exclusivement dans les fonctions beginShape () et endShape () .

vertex(xCoord,yCoord );

}

// la fonction endShape () est le compagnon de beginShape () et ne

// peut être appelée qu'après beginShape () . Lorsque endShape ()

// est appelée, toutes les données d'image définies depuis l'appel

// précédent à beginShape () sont écrites dans le tampon d'image.

// La constante CLOSE comme valeur pour le paramètre MODE pour fermer la forme

endShape(CLOSE);

}

Retour au sommaire

Pour tout problème

Pour tout problème de téléchargement ou pour nous suivre sur les réseaux sociaux voici les plateformes sur lesquelles nous éditons.
Cliquez sur celles qui vous intéressent .

Facebook Twitter Youtube

Retour au sommaire

Communication Pc vers Arduino lecture d’une variable

Mise à jour le 15/01/2021 : Article traitant de la communication entre la carte Arduino et Processing via votre pc en liaison série ( par les ports Usb )

Continuer la lecture →

Module uStepper S

Mise à jour le 01/11/2019 . Article traitant de la carte de commande de moteurs pas-à-pas Nema 17 permettant le suivi de la position absolue de l’arbre du moteur (détection d’éventuelles pertes de pas).

Continuer la lecture →