le Blog du Clergeot !

Catégorie :

Arduino

Fil des billets

Robot Pololu autonome avec capteur à ultrason

dans la catégorie Arduino

Voilà les premiers essais du petit robot Pololu équipé d'une platine arduino, d'un shield sparkfun ardumoto pour piloter les moteurs CC, d'un shield ProtoScrewShield sparkfun toujours et d'un dernier shield, solar charger v2 de chez SeeedStudio et d'unebatterie Li-ion 3,7V - 2000 mAh, de 2 capteurs mécanique et d'un à ultrason (SRF05).



























Le programme ici : pololu_ultrason_et_capteurs.abp

La vidéo là :



Yeti, ses premiers pas !

dans la catégorie Arduino

Petit robot marcheur, le yeti (même pas peur !) est bien sympa ... voici ses premiers pas. La difficulté de programmation est de bien gérer le degré de rotation de chaque servomoteur afin qu'il ne "traine" pas les pieds, et c'est pas facile !

Le programme ArduBlock : test_yeti.abp


ArduBlock

dans la catégorie Arduino

Le logiciel ArduBlock est un plugin qui s’ajoute à l’IDE d'Arduino et qui vous permet de programmer en blocs de fonctions (un peu comme scracth4arduino ou appinventor pour android).


Il est dévellopé par David Li et HE Qichen sous licence GNU GPL v3.

L'intérêt d’ArduBlock est qu’il vous génère les lignes de codes … la platine Arduino devient donc tout de suite encore plus simple à utiliser !


Il est actuellement disponible en 8 langues, totalement traduit en français, japonnais, espagnole, et portugais brésilien (le logiciel est de base en anglais, Yes sir !).


Et en plus il intègre pour l'instant les modules TinkerKit, DFRobot  et Seeedstudio grove.


Ca donne ça :










Pour l’installer c’est très simple !

1 – Repérez votre dossier sketchbook en démarrant l’IDE Arduino et en vous rendant dans les paramètres de l’IDE (dans « File » puis « Preferences »).

2 – Téléchargez ardublock ici : https://github.com/taweili/ardublock/downloads

3 – Rendez-vous dans le répertoire de votre scketchbook et créez cette arborescence :

[chemin de votre sketchbook]/tools/ArduBlockTool/tool/

4 – Copiez simplement ardublock-all.jar à l’intérieur du répertoire créé.

5 – Redémarrez l’IDE Arduino et commencez à créer votre premier sketch en blocs en vous rendant dans le menu Tools>Ardublock !

6 – Une fois vos blocs assemblés (n’oubliez pas de commencer par une boucle), cliquez sur Upload et hop ! le code est construit dans votre IDE et transféré dans la platine Arduino… magique non ?

Plus d'infos et d'exemples en français sur mon blog et en anglais sur le blog d'ArduBlock et surtout ici : http://blog.ardublock.com/category/community/

Merci à Julien Rat, David Li, HE Qichen et Semageek.

Theremin basique avec arduino et ArduBlock !

dans la catégorie Arduino

Voilà un petit exemple d'utilisation d'un capteur à ultrason (ici le SRF05) associé à un petit piezzo qui sert de haut parleur.

La vidéo :

Le schéma de cablage :


























Le programme :













Télécharger le programme theremin_basic.abp


Traduction des exemples du livre "Getting started with arduino" avec ArduBlock

dans la catégorie Arduino

Afin de se familiariser avec l'utilisation d'ArduBlock, j'ai traduit les exemples du livre de Massimo Banzi "Getting started with arduino" en blocks.

Voilà le travail :

- Exemple 01 -










Télécharger le fichier : exemple01.abp

 
- Exemple 02 -









Télécharger le fichier : exemple02.abp


- Exemple 03a -












Télécharger le fichier : exemple03a.abp


- Exemple 03b -



















Télécharger le fichier : exemple03b.abp


- Exemple 03c -




















Télécharger le fichier : exemple03c.abp


- Exemple 04 -






















Télécharger le fichier : exemple04.abp


- Exemple 05 -

























Télécharger le fichier : exemple05.abp


- Exemple 06a -









Télécharger le fichier : exemple06a.abp


- Exemple 06b -





Télécharger le fichier : exemple06b.abp


- Exemple 07 -




Télécharger le fichier : exemple07.abp

Nouvelle version d'ArduBlock, en français, espagnole, japonnais, chinois, portugais ...

dans la catégorie Arduino


Alors là c'est du lourd, la nouvelle version d'Ardublock est disponible ici : blog ArduBlock
 en 8 langues différentes dont 4 entièrement : français, espagnole, japonnais et portugais (brésilien).

Pour l'installation c'est ici.

J'ai participé avec le concepteur David Li à la traduction française et participe à son amélioration. Si vous avez des idées, participez via les liens sur le blog ArduBlock ici


Plate-forme élévatrice A4 hackée avec arduino et ardublock !

dans la catégorie Arduino

Salut tout le monde,

une maquette de plus sauvagement hackée avec arduino et une shield de prototypage, ça donne ça :






















Petite vidéo pour la montée :


Petite vidéo pour la descente :


ArduBlock

dans la catégorie Arduino

Un petit "plugin" pour IDE Arduino qui permet de programmer en blocs de fonctions. Il génère ensuite les lignes de codes, Donc autant dire très pratique !

Ca donne ça :

Fichier à télécharger ici : ardublock-all-french.jar

Ensuite il faut créer l'arborescence suivante :  [chemin de votre sketchbook]/tools/ArduBlockTool/tool/

Et copier ardublock-all-french.jar dedans !

Dans l'IDE Arduino, aller dans Tools/ArduBlock Tool et c'est parti !

Merci à Julien RAT, Semageek et bien sur le concepteur David Li !

Blog ArduBlocks


Hack du portail coulissant de chez A4 avec Arduino !

dans la catégorie Arduino

Maquette de portail coulissant de chez A4, hacké avec une platine Arduino. Les modules électroniques (boutons, Led, barrière IR, moteur) sont 100% compatible avec Arduino, c'est bon ça !

Un exemple de fonctionnement : on appuie sur un des boutons, ça s'ouvre. Au bout de 5s, ça se ferme. Si un objet est détecté par la barrière IR lors de la fermeture, ça s'ouvre. Petit plus : un message s'affiche grâce au port série d'Arduino sur l'ordi, ouverture ou fermeture (on peut imaginer un message sonore aussi !)

Tout ça programmé avec ArduBlock, une superbe extension à IDE Arduino !

Vidéo ici : Portrail A4

Et le fichier ArduBlock ici : portail ardublock


Arduino + capteur ultrason SRF05 + servo + processing = Sonar

dans la catégorie Arduino

Alors j'ai testé ce petit programme trouvé sur le très bon site de Lucky Larry.

Il faut donc une platine Arduino (ici Uno), un capteur ultrason (ici SRF05), un servomoteur et le programme processing (ici), qui ressemble à IDE d'Arduino.

On câble tout ça comme ça :



Ensuite le code pour Arduino :

/*
luckylarry.co.uk
Radar Screen Visualisation for SRF-05
Sends sensor readings for every degree moved by the servo
values sent to serial port to be picked up by Processing
*/

#include <Servo.h> // include the standard servo library
Servo leftRightServo; // set a variable to map the servo
int leftRightPos = 0; // set a variable to store the servo position
const int numReadings = 10; // set a variable for the number of readings to take
int index = 0; // the index of the current reading
int total = 0; // the total of all readings
int average = 0; // the average
int echoPin = 2; // the SRF05's echo pin
int initPin = 3; // the SRF05's init pin
unsigned long pulseTime = 0; // variable for reading the pulse
unsigned long distance = 0; // variable for storing distance
 
/* setup the pins, servo and serial port */
void setup() {
leftRightServo.attach(9);
// make the init pin an output:
pinMode(initPin, OUTPUT);
// make the echo pin an input:
pinMode(echoPin, INPUT);
// initialize the serial port:
Serial.begin(9600);
}
 
/* begin rotating the servo and getting sensor values */
void loop() {
for(leftRightPos = 0; leftRightPos < 180; leftRightPos++) { // going left to right.
leftRightServo.write(leftRightPos);
for (index = 0; index<=numReadings;index++) { // take x number of readings from the sensor and average them
digitalWrite(initPin, LOW);
delayMicroseconds(50);
digitalWrite(initPin, HIGH); // send signal
delayMicroseconds(50); // wait 50 microseconds for it to return
digitalWrite(initPin, LOW); // close signal
pulseTime = pulseIn(echoPin, HIGH); // calculate time for signal to return
distance = pulseTime/58; // convert to centimetres
total = total + distance; // update total
delay(10);
}
average = total/numReadings; // create average reading
 
if (index >= numReadings) { // reset the counts when at the last item of the array
index = 0;
total = 0;
}
Serial.print("X"); // print leading X to mark the following value as degrees
Serial.print(leftRightPos); // current servo position
Serial.print("V"); // preceeding character to separate values
Serial.println(average); // average of sensor readings
}
/*
start going right to left after we got to 180 degrees
same code as above

*/

for(leftRightPos = 180; leftRightPos > 0; leftRightPos--) { // going right to left
leftRightServo.write(leftRightPos);
for (index = 0; index<=numReadings;index++) {
digitalWrite(initPin, LOW);
delayMicroseconds(50);
digitalWrite(initPin, HIGH);
delayMicroseconds(50);
digitalWrite(initPin, LOW);
pulseTime = pulseIn(echoPin, HIGH);
distance = pulseTime/58;
total = total + distance;
delay(10);
}
average = total/numReadings;
if (index >= numReadings) {
index = 0;
total = 0;
}
Serial.print("X");
Serial.print(leftRightPos);
Serial.print("V");
Serial.println(average);
}
}

Et le code pour processing :

/*
luckylarry.co.uk
Radar Screen Visualisation for Sharp GP2Y0A02
Maps out an area of what the GP2Y0A02 sees from a top down view.
Takes and displays 2 readings, one left to right and one right to left.
Displays an average of the 2 readings
Displays motion alert if there is a large difference between the 2 values.
*/

import processing.serial.*; // import serial library
Serial myPort; // declare a serial port
float x, y; // variable to store x and y co-ordinates for vertices
int radius = 350; // set the radius of objects
int w = 300; // set an arbitary width value
int degree = 0; // servo position in degrees
int value = 0; // value from sensor
int motion = 0; // value to store which way the servo is panning
int[] newValue = new int[181]; // create an array to store each new sensor value for each servo position
int[] oldValue = new int[181]; // create an array to store the previous values.
PFont myFont; // setup fonts in Processing
int radarDist = 0; // set value to configure Radar distance labels
int firstRun = 0; // value to ignore triggering motion on the first 2 servo sweeps
 
/* create background and serial buffer */
void setup(){
// setup the background size, colour and font.
size(750, 450);
background (0); // 0 = black
myFont = createFont("verdana", 12);
textFont(myFont);
// setup the serial port and buffer
myPort = new Serial(this, Serial.list()[1], 9600);
myPort.bufferUntil('\n');
}
 
/* draw the screen */
void draw(){
fill(0); // set the following shapes to be black
noStroke(); // set the following shapes to have no outline
ellipse(radius, radius, 750, 750); // draw a circle with a width/ height = 750 with its center position (x and y) set by the radius
rectMode(CENTER); // set the following rectangle to be drawn around its center
rect(350,402,800,100); // draw rectangle (x, y, width, height)
if (degree >= 179) { // if at the far right then set motion = 1/ true we're about to go right to left
motion = 1; // this changes the animation to run right to left
}
if (degree <= 1) { // if servo at 0 degrees then we're about to go left to right
motion = 0; // this sets the animation to run left to right
}
/* setup the radar sweep */
/*
We use trigonmetry to create points around a circle.
So the radius plus the cosine of the servo position converted to radians
Since radians 0 start at 90 degrees we add 180 to make it start from the left
Adding +1 (i) each time through the loops to move 1 degree matching the one degree of servo movement
cos is for the x left to right value and sin calculates the y value
since its a circle we plot our lines and vertices around the start point for everything will always be the center.
*/

strokeWeight(7); // set the thickness of the lines
if (motion == 0) { // if going left to right
for (int i = 0; i <= 20; i++) { // draw 20 lines with fading colour each 1 degree further round than the last
stroke(0, (10*i), 0); // set the stroke colour (Red, Green, Blue) base it on the the value of i
line(radius, radius, radius + cos(radians(degree+(180+i)))*w, radius + sin(radians(degree+(180+i)))*w); // line(start x, start y, end x, end y)
}
} else { // if going right to left
for (int i = 20; i >= 0; i--) { // draw 20 lines with fading colour
stroke(0,200-(10*i), 0); // using standard RGB values, each between 0 and 255
line(radius, radius, radius + cos(radians(degree+(180+i)))*w, radius + sin(radians(degree+(180+i)))*w);
}
}
/* Setup the shapes made from the sensor values */
noStroke(); // no outline
/* first sweep */
fill(0,50,0); // set the fill colour of the shape (Red, Green, Blue)
beginShape(); // start drawing shape
for (int i = 0; i < 180; i++) { // for each degree in the array
x = radius + cos(radians((180+i)))*((oldValue[i]*2)); // create x coordinate
y = radius + sin(radians((180+i)))*((oldValue[i]*2)); // create y coordinate
vertex(x, y); // plot vertices
}
endShape(); // end shape
/* second sweep */
fill(0,110,0);
beginShape();
for (int i = 0; i < 180; i++) {
x = radius + cos(radians((180+i)))*(newValue[i]*2);
y = radius + sin(radians((180+i)))*(newValue[i]*2);
vertex(x, y);
}
endShape();
/* average */
fill(0,170,0);
beginShape();
for (int i = 0; i < 180; i++) {
x = radius + cos(radians((180+i)))*(((newValue[i]+oldValue[i])/2)*2); // create average
y = radius + sin(radians((180+i)))*(((newValue[i]+oldValue[i])/2)*2);
vertex(x, y);
}
endShape();
/* if after first 2 sweeps, highlight motion with red circle*/
if (firstRun >= 360) {
stroke(150,0,0);
strokeWeight(1);
noFill();
for (int i = 0; i < 180; i++) {
if (oldValue[i] - newValue[i] > 35 || newValue[i] - oldValue[i] > 35) {
x = radius + cos(radians((180+i)))*(newValue[i]*2);
y = radius + sin(radians((180+i)))*(newValue[i]*2);
ellipse(x, y, 10, 10);
}
}
}
/* set the radar distance rings and out put their values, 50, 100, 150 etc.. */
for (int i = 0; i <=6; i++){
noFill();
strokeWeight(1);
stroke(0, 255-(30*i), 0);
ellipse(radius, radius, (100*i), (100*i));
fill(0, 100, 0);
noStroke();
text(Integer.toString(radarDist+25), 380, (305-(radarDist*2)), 50, 50); // change this to measure up to 150cm
radarDist+=25;
}
radarDist = 0;
/* draw the grid lines on the radar every 30 degrees and write their values 180, 210, 240 etc.. */
for (int i = 0; i <= 6; i++) {
strokeWeight(1);
stroke(0, 55, 0);
line(radius, radius, radius + cos(radians(180+(30*i)))*w, radius + sin(radians(180+(30*i)))*w);
fill(0, 55, 0);
noStroke();
if (180+(30*i) >= 300) {
text(Integer.toString(180+(30*i)), (radius+10) + cos(radians(180+(30*i)))*(w+10), (radius+10) + sin(radians(180+(30*i)))*(w+10), 25,50);
} else {
text(Integer.toString(180+(30*i)), radius + cos(radians(180+(30*i)))*w, radius + sin(radians(180+(30*i)))*w, 60,40);
}
}
/* Write information text and values. */
noStroke();
fill(0);
rect(350,402,800,100);
fill(0, 100, 0);
text("Degrees: "+Integer.toString(degree), 100, 380, 100, 50); // use Integet.toString to convert numeric to string as text() only outputs strings
text("Distance: "+Integer.toString(value), 100, 400, 100, 50); // text(string, x, y, width, height)
text("Radar screen code at luckylarry.co.uk", 540, 380, 250, 50);
fill(0);
rect(70,60,150,100);
fill(0, 100, 0);
text("Screen Key:", 100, 50, 150, 50);
fill(0,50,0);
rect(30,53,10,10);
text("First sweep", 115, 70, 150, 50);
fill(0,110,0);
rect(30,73,10,10);
text("Second sweep", 115, 90, 150, 50);
fill(0,170,0);
rect(30,93,10,10);
text("Average", 115, 110, 150, 50);
noFill();
stroke(150,0,0);
strokeWeight(1);
ellipse(29, 113, 10, 10);
fill(150,0,0);
text("Motion", 115, 130, 150, 50);
}
 
/* get values from serial port */
void serialEvent (Serial myPort) {
String xString = myPort.readStringUntil('\n'); // read the serial port until a new line
if (xString != null) { // if theres data in between the new lines
xString = trim(xString); // get rid of any whitespace just in case
String getX = xString.substring(1, xString.indexOf("V")); // get the value of the servo position
String getV = xString.substring(xString.indexOf("V")+1, xString.length()); // get the value of the sensor reading
degree = Integer.parseInt(getX); // set the values to variables
value = Integer.parseInt(getV);
/*
If our values are outside either end of the sensors range then convert them to the max/min for a better display without the spikes
*/

if (value > 150) {
value = 150;
}
if (value < 20) {
value = 20;
}
oldValue[degree] = newValue[degree]; // store the values in the arrays.
newValue[degree] = value;
/* sets a counter to allow for the first 2 sweeps of the servo */
firstRun++;
if (firstRun > 360) {
firstRun = 360; // keep the value at 360
}
}
}

Ca donne ça :


















A tester : les différences de détection en fonction des matériaux des objets ...

Un grand merci à Lucky Harry pour ce tuto for sympathique !


page 2 de 2 -