Vue de l'arrière de r-Robot

Câblage.

Vue de devant de r-Robot

Un petit programme en langage C (du numérique) pour animer votre r-Robot simplement parce que que dans le monde l'électronique de nos jours tout est au numérique. 

A l'attention des débutants : Regardez bien les calculs et les valeurs normalisés des résistances car celles du schéma ne sont pas les bonnes valeurs. Pour dire que vous ne trouverez nullpart  et surtout les magazines d'électroniques un le schéma sans erreurs. Disons que ce ne sont que des approximations voir des supputations. Bref !

PROGRAMME DU MODULE ARDUINO UNO - Programme v2.0

//Please download the Arduino library!
//The link:http://www.dfrobot.com/image/data/DFR0154/LiquidCrystal_I2Cv1-1.rar
//DFRobot.com
//Compatible with the Arduino IDE 1.0
//Library version:1.1
#include <Wire.h> // Librairie Wire
#include <LiquidCrystal_I2C.h> // Librairie I2C
#include <Servo.h>

// Version 2022

#if defined(ARDUINO) && ARDUINO >= 100
#define printByte(args) write(args);
#else
#define printByte(args) print(args,BYTE);
#endif

// Déclaration des constantes
#define trig 4
#define echo 3
float powersupply = analogRead(A0);
word nn = 0; // VARIABLE intermédiaire aff pwr
int valeur = 0;
int duration;
const word ele = 13; // Avant - Arrière
const word ail = 12; // Gauche - Droite
const word thro = 11; // Gaz - Mode 1
const word rud = 8; // Translation
long durationele;
long durationail;
long durationthro;
long durationrud;

 

int dleft;
int dright;
int distance;
int distanceleft;
int distanceright; //declaration of the variables
boolean strut = 0; // Ultrzcon utiliser au moins une fois
byte right = 255; // Moteur Droit
byte left = 255; // Moteur Gauche
byte forward = 0; // Marche avanat ou marche arriere
boolean stopmtr = 1;

Servo monServo; // Déclaration de monServo

uint8_t bell[8] = {0x4, 0xe, 0xe, 0xe, 0x1f, 0x0, 0x4};
uint8_t note[8] = {0x2, 0x3, 0x2, 0xe, 0x1e, 0xc, 0x0};
uint8_t timer[8] = {0x0, 0xe, 0x15, 0x17, 0x11, 0xe, 0x0};
uint8_t heart[8] = {0x0, 0xa, 0x1f, 0x1f, 0xe, 0x4, 0x0};
uint8_t duck[8] = {0x0, 0xc, 0x1d, 0xf, 0xf, 0x6, 0x0};
uint8_t check[8] = {0x0, 0x1, 0x3, 0x16, 0x1c, 0x8, 0x0};
uint8_t cross[8] = {0x0, 0x1b, 0xe, 0x4, 0xe, 0x1b, 0x0};
uint8_t retarrow[8] = { 0x1, 0x1, 0x5, 0x9, 0x1f, 0x8, 0x4};

LiquidCrystal_I2C lcd(0x20, 20, 4); // set the LCD address to 0x20 for a 20 chars and 4 line display (All jumpers should be connected!)

int position = 90; // Position strait

// ##################################################################################################

void setup()
{

int var = 0; // VARIABLE CONTER DELAY

Serial.begin(1200);
lcd.init(); // initialize the lcd
lcd.backlight();

lcd.createChar(0, bell);
lcd.createChar(1, note);
lcd.createChar(2, timer);
lcd.createChar(3, heart);
lcd.createChar(4, duck);
lcd.createChar(5, check);
lcd.createChar(6, cross);
lcd.createChar(7, retarrow);
lcd.home();

lcd.setCursor(0, 0);

lcd.init(); // initialize the lcd
lcd.print("r-Robot (c)2022 V2.2"); lcd.printByte(3);
lcd.setCursor(0, 1);
lcd.print("triptraptroopcompany");
lcd.setCursor(0, 2); lcd.print("Power Engine");
lcd.setCursor(0, 3);
lcd.print(" x"); lcd.printByte(6); lcd.print("x x"); lcd.printByte(6); lcd.print("x x");
lcd.printByte(6); lcd.print("x ");
delay(1000);
lcd.clear();

pinMode(0, OUTPUT); // Broche buzzer
pinMode(6, OUTPUT); // PWM RIGHT + Gauche
pinMode(5, OUTPUT); // Broche pwm- Gauche
pinMode(7, OUTPUT); // Broche servo
pinMode(trig, OUTPUT); // TRIGGER ULTRASON SORTIE
pinMode(echo, INPUT); // ECHO ULTRASON ENTREE
pinMode(powersupply, INPUT); // ADC10 MAX 14VOLTS
pinMode(forward, INPUT);

pinMode(10, OUTPUT); // PWM LEFT + Droit

pinMode(2, INPUT);
pinMode(9, OUTPUT); // PWM LEFT - Droit
pinMode(ele, INPUT); // Avant - Arrière
pinMode(ail, INPUT); // Gauche - Droite
pinMode(thro, INPUT); // Gaz - Mode 1
pinMode(rud, INPUT); // Translation

monServo.attach(7); // Connexion à la broche 7
monServo.write(90); // Rotation à Position

// ##################################################################################################
// ##################################################################################################
// ##################################################################################################
}

void loop()
{
digitalWrite(0, LOW);

lcd.init(); // initialize the lcd
lcd.backlight();
lcd.setCursor(0, 0);
lcd.print("r-Robot (c)2022 V2.3"); lcd.printByte(3);
lcd.setCursor(0, 1);
lcd.print("Pwr:"); lcd.setCursor(4, 1); lcd.print(powersupply); lcd.setCursor(8, 1); lcd.print("V / ");
lcd.print("Mtr:"); lcd.print(nn); lcd.print("% ");
lcd.setCursor(14, 2);
lcd.print(" "); lcd.print(distanceleft);lcd.print("cm ");
lcd.setCursor(7, 2);
lcd.print(" "); lcd.print(distance);lcd.print("cm ");
lcd.setCursor(0, 2);
lcd.print(" "); lcd.print(distanceright);lcd.print("cm ");
lcd.setCursor(0, 3); lcd.print(" "); lcd.print(durationele); lcd.print("% ");
lcd.setCursor(8, 3); lcd.print(durationail); lcd.print("% "); lcd.setCursor(15, 3);
lcd.print(durationrud); lcd.print("% ");

// action des moteurs
power();

for (int var = 0; var <= 1 ; var++) { // BOUCLE DE DETECTION D'ACTION DES MOTEURS
digitalWrite(0, HIGH);
recepteur();
digitalWrite(0, LOW);
engine();

// #######################################################################################
// #######################################################################################
// #######################################################################################

if (forward == LOW) { // Marche avant

if (right < 128 | left < 128) {
if (right < 128 && left > 128) {
monServo.write(115); // Rotation à Position
delay(500);

digitalWrite(trig, LOW); //set the trig pin to low
delayMicroseconds(2000); //pause to let signal settle
digitalWrite(trig, HIGH); //set the trig pin to high
delayMicroseconds(10); //pause signal at high state
digitalWrite(trig, LOW); //set the trig pin to low
dright = pulseIn(echo, HIGH); //measure time at echo pin in microseconds
distanceright = dright / 58; //converting the time in distance(centimeters)

monServo.write(90); // Rotation à Position
delay(500);

lcd.setCursor(0, 2);
lcd.print(" "); lcd.print(distanceright);
lcd.print("cm");

if (distanceright > 20) {
analogWrite(10, 0);
analogWrite(9, valeur); // PWM DROIT Arrière
analogWrite(6, valeur);
analogWrite(5, 0); // PWM Gauche Avant
strut = 0;
}
else {
analogWrite(10, 0); // Arrêt du moteur droit
analogWrite(9, 0); // Arrêt de moteur Gauche
analogWrite(6, 0); // Arrêt du moteur droit
analogWrite(5, 0); // Arrêt de moteur Gauche
strut = 0;
}

if (var == 0 && strut == 0) {
strut = 1;
}
}

if (left < 128 && right > 128) {
monServo.write(65); // Rotation à Position
delay(500);

digitalWrite(trig, LOW); //set the trig pin to low
delayMicroseconds(2000); //pause to let signal settle
digitalWrite(trig, HIGH); //set the trig pin to high
delayMicroseconds(10); //pause signal at high state
digitalWrite(trig, LOW); //set the trig pin to low
dleft = pulseIn(echo, HIGH); //measure time at echo pin in microseconds
distanceleft = dleft / 58; //converting the time in distance(centimeters)
monServo.write(90); // Rotation à Position
delay(500);

lcd.setCursor(14, 2);
lcd.print(" "); lcd.print(distanceleft);lcd.print("cm");
lcd.print(" ");

if (distanceleft > 20) {
analogWrite(9, 0);
analogWrite(10, valeur); // PWM DROIT Avant
analogWrite(5, valeur);
analogWrite(6, 0); // PWM Gauche arrière
strut = 0;
}
else {
analogWrite(10, 0); // Arrêt du moteur droit
analogWrite(9, 0); // Arrêt de moteur Gauche
analogWrite(6, 0); // Arrêt du moteur droit
analogWrite(5, 0); // Arrêt de moteur Gauche
strut = 0;
}
if (var == 0 && strut == 0) {
strut = 1;
}

}

if (right < 128 && left < 128) {
digitalWrite(trig, LOW); //set the trig pin to low
delayMicroseconds(2000); //pause to let signal settle
digitalWrite(trig, HIGH); //set the trig pin to high
delayMicroseconds(10); //pause signal at high state
digitalWrite(trig, LOW); //set the trig pin to low
duration = pulseIn(echo, HIGH); //measure time at echo pin in microseconds
distance = duration / 58; //converting the time in distance(centimeters)

lcd.setCursor(7, 2);
lcd.print(" "); lcd.print(distance);lcd.print("cm");
if (distance > 20) {
analogWrite(9, valeur);
analogWrite(10, 0); // PWM DROIT de 0 à 255
analogWrite(6, 0);
analogWrite(5, valeur); // PWM Gauche de 2 à 255
}

else {
analogWrite(10, 0); // Arrêt du moteur droit
analogWrite(9, 0); // Arrêt de moteur Gauche
analogWrite(6,0); // Arrêt du moteur droit
analogWrite(5, 0); // Arrêt de moteur Gauche
strut = 0;
}

strut = 0;

}
}

if (right > 128 && left > 128) {
analogWrite(10, 0); // Arrêt du moteur droit
analogWrite(9, 0); // Arrêt de moteur Gauche
analogWrite(6, 0); // Arrêt du moteur droit
analogWrite(5, 0); // Arrêt de moteur Gauche
if (var == 0 && strut == 0) {
ultra();
strut = 1;

}
}

}
else { // Marche arrière

// #######################################################################################

if (right < 128 | left < 128) {

if (right < 128 && left > 128) {
analogWrite(10, valeur);
analogWrite(9, 0); // PWM DROIT de 0 à 255
analogWrite(6, 0);
analogWrite(5, valeur); // PWM Gauche de 2 à 255
strut = 0;
// engine();
}

if (left < 128 && right > 128) {
analogWrite(9, valeur);
analogWrite(10, 0); // PWM DROIT de 0 à 255
analogWrite(5, 0);
analogWrite(6, valeur); // PWM Gauche de 2 à 255
strut = 0;
}

if (right < 128 && left < 128) { // Marche arrière

analogWrite(9, 0);
analogWrite(10, valeur); // PWM DROIT arrière
analogWrite(6, valeur);
analogWrite(5, 0); // PWM Gauche arrière
strut = 0;

}
}

if (right > 128 && left > 128) { // Arrêt des moteur
analogWrite(10, 0); // Arrêt du moteur droit
analogWrite(9, 0); // Arrêt de moteur Gauche
analogWrite(6, 0); // Arrêt du moteur droit
analogWrite(5, 0); // Arrêt de moteur Gauche
}

}

// #######################################################################################
// #######################################################################################
}
// #######################################################################################

 

// Fin détection d'action des moteurs
lcd.init(); // initialize the lcd
lcd.backlight();
lcd.setCursor(0, 0);
lcd.print(" r-Robot (c)2019 "); lcd.print(" ");
lcd.setCursor(0, 1);
lcd.print("Pwr:"); lcd.setCursor(4, 1); lcd.print(powersupply);
lcd.setCursor(8, 1); lcd.print("V / "); lcd.print("Mtr:"); lcd.print(nn); lcd.print("% ");
lcd.setCursor(14, 2);
lcd.print(" "); lcd.print(distanceleft);lcd.print("cm ");
lcd.setCursor(7, 2);
lcd.print(" "); lcd.print(distance);lcd.print("cm ");
lcd.setCursor(0, 2);
lcd.print(" "); lcd.print(distanceright);lcd.print("cm ");
lcd.setCursor(0, 3); lcd.print(" "); lcd.print(durationele); lcd.print("% ");
lcd.setCursor(8, 3); lcd.print(durationail); lcd.print("% ");
lcd.setCursor(15, 3); lcd.print(durationrud); lcd.print("% ");

// action des moteurs

power();

for (int var = 0; var <= 1 ; var++) { // BOUCLE DE DETECTION D'ACTION DES MOTEURS
digitalWrite(0,HIGH);
recepteur();
digitalWrite(0, LOW);
engine();

// #######################################################################################
// #######################################################################################
// #######################################################################################

if (forward == LOW) { // Marche avant
if (right < 128 | left < 128) {

if (right < 128 && left > 128) { // droite
monServo.write(115); // Rotation à Position
delay(500);

analogWrite(trig, LOW); //set the trig pin to low
delayMicroseconds(2000); //pause to let signal settle
analogWrite(trig, HIGH); //set the trig pin to high
delayMicroseconds(10); //pause signal at high state
analogWrite(trig, LOW); //set the trig pin to low
dright = pulseIn(echo, HIGH); //measure time at echo pin in microseconds
distanceright = dright / 58; //converting the time in distance(centimeters)
lcd.setCursor(0, 2);
lcd.print(" "); lcd.print(distanceright);
lcd.print("cm");

monServo.write(90); // Rotation à Position
delay(500);

if (distanceright > 20) {
analogWrite(10, 0);
analogWrite(9, valeur); // PWM DROIT de 0 à 255
analogWrite(6, valeur);
analogWrite(5, 0); // PWM Gauche de 2 à 255
strut = 0;
}
else {
analogWrite(10, 0); // Arrêt du moteur droit
analogWrite(9, 0); // Arrêt de moteur Gauche
analogWrite(6, 0); // Arrêt du moteur droit
analogWrite(5, 0); // Arrêt de moteur Gauche
strut = 0;
}
if (var == 0 && strut == 0) {
strut = 1;

}

}

if (left < 128 && right > 128) { // Gauche
monServo.write(65); // Rotation à Position
delay(500);

digitalWrite(trig, LOW); //set the trig pin to low
delayMicroseconds(2000); //pause to let signal settle
digitalWrite(trig, HIGH); //set the trig pin to high
delayMicroseconds(10); //pause signal at high state
digitalWrite(trig, LOW); //set the trig pin to low
dleft = pulseIn(echo, HIGH); //measure time at echo pin in microseconds
distanceleft = dleft / 58; //converting the time in distance(centimeters)
monServo.write(90); // Rotation à Position
delay(500);

lcd.setCursor(14, 2);
lcd.print(" "); lcd.print(distanceleft);
lcd.print("cm");

if (distanceleft > 20) {
if (distance > 20) {
analogWrite(9, valeur);
analogWrite(10, 0); // PWM DROIT de 0 à 255
analogWrite(6, 0);
analogWrite(5, valeur); // PWM Gauche de 2 à 255
}
strut = 0;
}
else {
analogWrite(10, 0); // Arrêt du moteur droit
analogWrite(9, 0); // Arrêt de moteur Gauche
analogWrite(6, 0); // Arrêt du moteur droit
analogWrite(5, 0); // Arrêt de moteur Gauche
strut = 0;
}
if (var == 0 && strut == 0) {
strut = 1;
}

}

if (right < 128 && left < 128) { // Avant
digitalWrite(trig, LOW); //set the trig pin to low
delayMicroseconds(2000); //pause to let signal settle
digitalWrite(trig, HIGH); //set the trig pin to high
delayMicroseconds(10); //pause signal at high state
digitalWrite(trig, LOW); //set the trig pin to low
duration = pulseIn(echo, HIGH); //measure time at echo pin in microseconds
distance = duration / 58; //converting the time in distance(centimeters)

lcd.setCursor(7, 2);
lcd.print(" "); lcd.print(distance);lcd.print("cm");
if (distance > 20) {
analogWrite(9, valeur);
analogWrite(10, 0); // PWM DROIT de 0 à 255
analogWrite(6, 0);
analogWrite(5, valeur); // PWM Gauche de 2 à 255
}
else {
analogWrite(10, 0); // Arrêt du moteur droit
analogWrite(9, 0); // Arrêt de moteur Gauche
analogWrite(6, 0); // Arrêt du moteur droit
analogWrite(5, 0); // Arrêt de moteur Gauche
strut = 0;
}

strut = 0;

}
}

if (right > 128 && left > 128) {
analogWrite(10, 0); // Arrêt du moteur droit
analogWrite(9, 0); // Arrêt de moteur Gauche
analogWrite(6, 0); // Arrêt du moteur droit
analogWrite(5, 0); // Arrêt de moteur Gauche
int valeur = 0;
if (var == 0 && strut == 0) {
ultra();
strut = 1;

}
}
}
else { // Marche arrière

// #######################################################################################

if (right < 128 | left < 128) {
if (right < 128 && left > 128) { // arrière droit
analogWrite(10, valeur);
analogWrite(9, 0); // PWM DROIT de 0 à 255
analogWrite(6, 0);
analogWrite(5, valeur); // PWM Gauche de 2 à 255
strut = 0;
}

if (left < 128 && right > 128) { // Arrière gauche
analogWrite(9, valeur);
analogWrite(10, 0); // PWM DROIT de 0 à 255
analogWrite(5, 0);
analogWrite(6, valeur); // PWM Gauche de 2 à 255
strut = 0;
}

if (right < 128 && left < 128) { // Arrière toute

analogWrite(9, 0);
analogWrite(10, valeur); // PWM DROIT arrière
analogWrite(6, valeur);
analogWrite(5, 0); // PWM Gauche arrière
strut = 0;

}
}

if (right > 128 && left > 128) {
analogWrite(10, 0); // Arrêt du moteur droit
analogWrite(9, 0); // Arrêt de moteur Gauche
analogWrite(6, 0); // Arrêt du moteur droit
analogWrite(5, 0); // Arrêt de moteur Gauche
strut = 0;
}

}

// #######################################################################################
// #######################################################################################

} // Fin détection d'action des moteur
// #######################################################################################

 

 

} // FIN DE LA BOUBLE PRINCIPALE LOOP
void ultra()
{
lcd.setCursor(0, 0);
lcd.printByte(2);

monServo.write(65); // Rotation à Position
delay(500);
digitalWrite(trig, LOW); //set the trig pin to low
delayMicroseconds(2000); //pause to let signal settle
digitalWrite(trig, HIGH); //set the trig pin to high
delayMicroseconds(10); //pause signal at high state
digitalWrite(trig, LOW); //set the trig pin to low
dleft = pulseIn(echo, HIGH); //measure time at echo pin in microseconds
distanceleft = dleft / 58; //converting the time in distance(centimeters)

monServo.write(90); // Rotation à Position
delay(500);
digitalWrite(trig, LOW); //set the trig pin to low
delayMicroseconds(2000); //pause to let signal settle
digitalWrite(trig, HIGH); //set the trig pin to high
delayMicroseconds(10); //pause signal at high state
digitalWrite(trig, LOW); //set the trig pin to low
duration = pulseIn(echo, HIGH); //measure time at echo pin in microseconds
distance = duration / 58; //converting the time in distance(centimeters)

monServo.write(115); // Rotation à Position
delay(500);
digitalWrite(trig, LOW); //set the trig pin to low
delayMicroseconds(2000); //pause to let signal settle
digitalWrite(trig, HIGH); //set the trig pin to high
delayMicroseconds(10); //pause signal at high state
digitalWrite(trig, LOW); //set the trig pin to low
dright = pulseIn(echo, HIGH); //measure time at echo pin in microseconds
distanceright = dright / 58; //converting the time in distance(centimeters)

monServo.write(90); // Rotation à Position
delay(500);

lcd.setCursor(14, 2);
lcd.print(" "); lcd.print(distanceleft);lcd.print("cm");
lcd.setCursor(7, 2);
lcd.print(" "); lcd.print(distance);lcd.print("cm");
lcd.setCursor(0, 2);
lcd.print(" "); lcd.print(distanceright);lcd.print("cm");

}
// #######################################################################################
void recepteur() {

durationail = pulseIn(ail, LOW); //measure time at echo pin in microseconds
durationail = pulseIn(ail, HIGH); //measure time at echo pin in microseconds
durationail = durationail - 680;
durationail = durationail * 100;
durationail = durationail / 1070;
if (durationail < 0) { // ail aileron forward backward
durationail = 75;
left = 255; // Moteur Gauche
right = 255;
}

if (durationail < 60 && durationail > 2) {
forward = 0;
left = 0; // Moteur Gauche
right = 0;
}
if (durationail > 85 && durationail < 130 ) {
forward = 1;
left = 0; // Moteur Gauche
right = 0;

}

durationele = pulseIn(ele, LOW); //measure time at echo pin in microseconds
durationele = pulseIn(ele, HIGH); //measure time at echo pin in microseconds
durationele = durationele - 680;
durationele = durationele * 100;
durationele = durationele / 1070;
if (durationele < 0) {
durationele = 75;
}

if (durationele < 60 && durationele > 2) { // ele eleron gauche droite
left = 0; // Moteur Gauche
right = 255;
}

if (durationele > 85 && durationele < 130 ) {
left = 255;
right = 0; // Moteur Droit
}
if (durationele > 59 && durationele < 86 && durationail > 61 && durationail < 86) {
left = 255; // Moteur Gauche
right = 255;
}

durationthro = pulseIn(thro, LOW); //measure time at echo pin in microseconds
durationthro = pulseIn(thro, HIGH); //measure time at echo pin in microseconds
durationthro = durationthro - 680;
durationthro = durationthro * 100;
durationthro = durationthro / 1070;
if (durationthro < 0) {
durationthro = 0;
}
if (durationthro < 60 && durationthro > 2) {

}
if (durationthro > 85 && durationthro < 130 ) {

}

durationrud = pulseIn(rud, LOW); //measure time at echo pin in microseconds
durationrud = pulseIn(rud, HIGH); //measure time at echo pin in microseconds
durationrud = durationrud - 680;
durationrud = durationrud * 100;
durationrud = durationrud / 1070;
if (durationrud < 0) {
durationrud = 75;
}
if (durationrud < 60 && durationrud > 2) { // Pourcentage niveau bas

}
if (durationrud > 85 && durationrud < 130 ) { // Pourcentage niveau haut

}

lcd.setCursor(0, 3); lcd.print(" "); lcd.print(durationele); lcd.print("% ");
lcd.setCursor(8, 3); lcd.print(durationail); lcd.print("% ");
lcd.setCursor(15, 3); lcd.print(durationrud); lcd.print("% ");

}
// #######################################################################################
void power() {
powersupply = analogRead(A0);
powersupply = powersupply * 0.004883;
powersupply = powersupply * 2.8;
powersupply = powersupply;

}

// #######################################################################################
void engine() {
if (durationthro >= 20) {
nn = map(durationthro, 34, 112, 0, 255);
valeur = map(durationthro, 0, 112, 0, 255);

}
// else
// {
// valeur = 0;
// }

 

} // fin de la boucle engine

Le module Arduino UNO une foi câble et alimenté en 12 Volts DC

Le module Arduino une foi câblé et alimenter.

* * *

Programme light