Projet Arduino Uno R3 avec interaction ordinateur Microsoft Team

[Wilder1626]

Bonjour les Bidouilleuses et Bidouilleurs,

6 jours et plusieurs heures de lecture et de formation Arduino (Udemy) plus tard, voici un vrai projet sur lequel je souhaitais ardemment me lancer.
Je me suis inspiré d'un projet déjà  réalisé par DeepLift sur Youtube en 2021 : https://www.youtube.com/watch?v=F_ZPMev6En0

Cette personne utilise l'Arduino Nano, mais je voulais reprendre ce projet avec l'Arduino Uno, et aussi ajouter du code et un écran LCD au projet.

Avant de réaliser le projet en propotype réel, j'ai utilisé "Tinkercad" pour construire le circuit et faire beaucoup d'erreurs / corrections sur celui-ci, mais aussi sur le code en C++.

Bien entendu, j'utiliserai également "AAC Keys" pour configurer les raccourcis pour l'ordinateur / Microsoft Team.

Voici le code que j'ai utilisé pour mon projet jusqu'à  présent, mais qui est encore en cours d'élaboration. Je pense ajouter autres choses :

Code Sélectionner Étendre

#include <LiquidCrystal.h>

const int start_call = 5;
const int end_call = 4;
const int toggle_mute = 6;
const int screen_share = 8;
const int hand_raise = 9;

const int rs = 2, e = 3, db4 = 13, db5 = 12, db6 = 11, db7 = 10;

LiquidCrystal lcd(rs, e, db4, db5, db6, db7);

const char* start_call_cmd = "\033,hold,ctrl,hold,shift.C";
const char* end_call_cmd = "\033,hold,ctrl,hold,shift.B";
const char* toggle_mute_cmd = "\033,hold,ctrl,hold,shift.M";
const char* screen_share_cmd = "\033,hold,ctrl,hold,shift.E";
const char* hand_raise_cmd = "\033,hold,ctrl,hold,shift.K";

bool appelEnCours = false;

void setup() {
  Serial.begin(9600);
  lcd.begin(16, 2); // Initialize LCD
  pinMode(start_call, INPUT_PULLUP);
  pinMode(end_call, INPUT_PULLUP);
  pinMode(toggle_mute, INPUT_PULLUP);
  pinMode(screen_share, INPUT_PULLUP);
  pinMode(hand_raise, INPUT_PULLUP);
}

void loop() {
  if (digitalRead(start_call)) {
    if (!appelEnCours) {
      appelEnCours = true;
      digitalWrite(start_call, HIGH); // Allume la LED lorsque l'appel démarre
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("Debut appel");
      sendCommand(start_call_cmd);
    }
  } else if (digitalRead(end_call)) {
    if (appelEnCours) {
      appelEnCours = false;
      digitalWrite(start_call, LOW); // Éteint la LED lorsque l'appel se termine
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("Fin appel");
      sendCommand(end_call_cmd);
    }
  } else if (digitalRead(toggle_mute)) {
    if (appelEnCours) {
      appelEnCours = true;
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("Sourdine");
      sendCommand(toggle_mute_cmd);
    }
  } else if (digitalRead(screen_share)) {
    if (appelEnCours) {
      appelEnCours = true;
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("Partage d'ecran");
      sendCommand(screen_share_cmd);
    }
  }  else if (digitalRead(hand_raise)) {
    if (appelEnCours) {
      appelEnCours = true;
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("Je voudrais parler");
      sendCommand(hand_raise_cmd);
    }
  }
  if (digitalRead(start_call)) {
    sendCommand(start_call_cmd);
  } else if (digitalRead(end_call)) {
    sendCommand(end_call_cmd);
  } else if (digitalRead(toggle_mute)) {
    sendCommand(toggle_mute_cmd);
  } else if (digitalRead(screen_share)) {
    sendCommand(screen_share_cmd);
  } else if (digitalRead(hand_raise)) {
    sendCommand(hand_raise_cmd);
  }
}

void sendCommand(const char* commande) {
  Serial.print(commande);
}

Liste de pièces:

Nom   Quantité   Composant
U1   1           Arduino Uno R3
R9   11           220 â,,¦ Résistance
D1   1           Vert LED
D2   1           Rouge LED
D3   1           Jaune LED
D4   1           Bleu LED
D5   1           Orange LED
S3   5           Bouton poussoir
U2   1           Écran LCD 16x2

[sylvainmahe]

Bonjour, je passe sur le code qui n'est pas très précis, rigoureux, grammaticalement approximatif et qui utilise des bibliothèques d'abstraction qui ne permettent aucunement de comprendre le fonctionnement de l'ATmega328P dont la documentation fait plusieurs centaines de pages.

Je préfère m'attarder sur mon incompréhension de ce schéma au départ, que j'ai réussi à  comprendre en suivant comme une fourmie les petits câbles.

Tes résistances de tirage vers le potentiel masse pourraient être plus élevées pour moins consommer. As-tu prévu des anti-rebonds pour tes boutons ?

C'est un premier message mais même si ton montage fonctionne certainement, il y a beaucoup à  dire pour améliorer tout ça. Je laisse le soin aux autres par manque de temps.

[Wilder1626]

Tout d'abord, je voulais vous remercier d'avoir pris le temps de regarder mon premier projet.
Étant un pur débutant, mais cherchant à  apprendre par moi-même en tant que hobby sur udemy, entre le travail et autres, j'avais toujours voulu apprendre à  faire des projets comme celui-ci.

Merci pour votre honnêteté, et surtout pour avoir dit les choses telles qu'elles sont. Je vais chercher à  améliorer certaines facettes de mon codage, et aussi à  me documenter sur les bibliothèques d'abstraction (que j'ai identifier sur le code à  jour) , et l'anti-rebond pour les boutons. Je vais également me pencher sur les résistances.

J'avais déjà  commencé a faire des améliorations, mais je continue de l'améliorer en temps que projet.

Code Sélectionner Étendre

#include <LiquidCrystal.h> // Inclut la bibliothèque d'abstraction pour l'écran LCD

// Définition des broches pour les boutons physiques
const int start_call = 9;
const int end_call = 10;
const int toggle_mute = 11;
const int screen_share = 12;
const int hand_raise = 13;

// Définition des broches pour l'écran LCD
const int rs = 3, e = 4, db4 = 5, db5 = 6, db6 = 7, db7 = 8;

// Initialisation de l'objet LCD
LiquidCrystal lcd(rs, e, db4, db5, db6, db7);

// Commandes à  envoyer lors de l'appui sur les boutons
const char* start_call_cmd = "\033,hold,ctrl,hold,shift.C";
const char* end_call_cmd = "\033,hold,ctrl,hold,shift.B";
const char* toggle_mute_cmd = "\033,hold,ctrl,hold,shift.M";
const char* screen_share_cmd = "\033,hold,ctrl,hold,shift.E";
const char* hand_raise_cmd = "\033,hold,ctrl,hold,shift.K";

// Variable pour suivre l'état de l'appel
bool appelEnCours = false;

void setup() {
  Serial.begin(9600); // Initialise la communication série
  lcd.begin(16, 2); // Initialise l'écran LCD avec 16 colonnes et 2 lignes

  // Configuration des broches des boutons en entrée avec résistance de tirage
  pinMode(start_call, INPUT_PULLUP);
  pinMode(end_call, INPUT_PULLUP);
  pinMode(toggle_mute, INPUT_PULLUP);
  pinMode(screen_share, INPUT_PULLUP);
  pinMode(hand_raise, INPUT_PULLUP);

  // Configuration des broches A0 et A1 comme des sorties pour contrôler les couleurs de la LED
  pinMode(A0, OUTPUT);
  pinMode(A1, OUTPUT);
 
  // Réglage initial des couleurs de la LED et de l'écran LCD
  updateLED(false);
  lcd.print("Pas sur un appel");
}

void loop() {
  if (digitalRead(start_call) && !appelEnCours) {
    appelEnCours = true;
    updateLED(true); // Allume la LED lorsque l'appel démarre
    lcdMessage("Debut appel");
    sendCommand(start_call_cmd);
  }

  if (digitalRead(end_call) && appelEnCours) {
    appelEnCours = false;
    updateLED(false); // Éteint la LED lorsque l'appel se termine
    lcdMessage("Fin appel");
    sendCommand(end_call_cmd);
  } else if (digitalRead(toggle_mute) && appelEnCours) {
    updateLED(false); // Éteint la LED lors de la sourdine
    lcdMessage("Sourdine");
    sendCommand(toggle_mute_cmd);
  } else if (digitalRead(screen_share) && appelEnCours) {
    updateLED(false); // Éteint la LED lors du partage d'écran
    lcdMessage("Partage d'ecran");
    sendCommand(screen_share_cmd);
  } else if (digitalRead(hand_raise) && appelEnCours) {
    updateLED(false); // Éteint la LED lors de la prise de parole
    lcdMessage("Prendre parole");
    sendCommand(hand_raise_cmd);
  }

  // Envoie les commandes même si les boutons ne sont pas enfoncés (peut-être pas nécessaire)
  if (digitalRead(start_call)) {
    sendCommand(start_call_cmd);
  } else if (digitalRead(end_call)) {
    sendCommand(end_call_cmd);
  } else if (digitalRead(toggle_mute)) {
    sendCommand(toggle_mute_cmd);
  } else if (digitalRead(screen_share)) {
    sendCommand(screen_share_cmd);
  } else if (digitalRead(hand_raise)) {
    sendCommand(hand_raise_cmd);
  }
}

// Fonction pour envoyer une commande
void sendCommand(const char* commande) {
  Serial.print(commande);
}

// Fonction pour mettre à  jour l'état de la LED
void updateLED(bool isOn) {
  digitalWrite(start_call, isOn ? HIGH : LOW);
  analogWrite(A0, isOn ? 0 : 255);
  analogWrite(A1, isOn ? 255 : 0);
}

// Fonction pour afficher un message sur l'écran LCD
void lcdMessage(const char* message) {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print(message);
}


[sylvainmahe]

Merci à  toi d'avoir posté cet exemple.

Je me rappelle quand j'ai débuté la programmation je me faisais défoncer sur les forums, quand j'ai débuté l'électronique je me faisais défoncer sur les forums, quand j'ai débuté l'aéromodélisme je me faisais défoncer sur les forums (enfin plus tard car j'avais pas internet au départ), quand j'ai débuté le graphisme...

Mon but n'est pas de défoncer comme ce que j'ai vu tellement de fois, mais j'aimerais que tu comprennes pourquoi dans une vie il ne faut pas passer plus d'une semaine sur arduino. Comment t'expliquer, cette plateforme qui est un paradigme parmi d'autres ne nous apprend rien sur l'électronique ni matérielle ni logicielle.

Quand on sort de ce paradigme on a de toute façon tout à  apprendre et déconstruire pleins d'idées reçues, pleins de choses qu'on croyait vraies parceque "ça marche" et qui sont fausses, ou des questions mal posées.