Projet d'illumination d'une maquette avec des leds RGB et des leds blanches

Bonjour Aurélien

La dernière étape.

Les dernières news:
Modification dans les commandes, il ne reste plus que:
ALL pour toutes les séries, couleurs 24 bits avec valeur en hexadécimal comme 00FF00 pour Vert
COH pour Corniche Haute (24 bits)
COB pour Corniche Basse (24 bits)
OBS pour Observatoire (24 bits)
CALAND pour mettre la date dans la tâche 4 (cal[4].time)
Dorénavant il faut mettre un = entre la commande et le paramètre comme COB=00FF00, pour Corniche bas en vert, tout ça dans la dernière version.

L'ajout d'un calendrier à 5 tâches (0-4)
Au départ, il y a un exemple de programmation:

	//--------------------------------- Initialisation du calendrier  time = "-" pour désactiver
	cal[0].time = "16:43"; cal[0].execute = !calTaskExec;
	cal[1].time = "01:15"; cal[1].execute = !calTaskExec;
	cal[2].time = "7"; cal[2].execute = !calTaskExec;
	cal[3].time = "31"; cal[3].execute = !calTaskExec;
	cal[4].time = "16:42"; cal[4].execute = !calTaskExec;

A noter que la tâche 4 peut être modifiée par la commande CALAND=11:20 (par ex.). Cette modification n'est pas sauvée.

La "mécanique" est ainsi:

	16:43	tout les jours à 16:43
	1:15	à 01:15, 11:15, 21:15 ...
	01:15	tout les jours à 01:15
	31	à 00:31, 01:31, 02:31 ...
	7	à 00:07, 00:17, 00:27, 00:37 ... 12:07, 12:17...

Et enfin, la sonde de lumière, de ce type
image
et câblée comme ceci:
image
Les paramètres sont:

lum.valeurSeuil = 600; (à régler selon le composant)
lum.changeTimeSec = 5; // La lumière doit changer au moins x secondes.

les actions se programment dans:

void lumChangeAction(boolean etat)
{
	Serial.print(F("Action lumiere Etat "));
	
	if (etat == lumEtatHaut)
	{
		Serial.println(F("Haut"));
		cmdExecute("OBS=0000FF");
	}
	else
	{
		Serial.println(F("Bas"));
		cmdExecute("OBS=FF0000");
	}
}

C'est à dire, si la lumière est haute, l'observatoire s'allumera en bleu, si la lumière est basse, en rouge.

Le programme complet:

/*-----------------------------------------------------------------------
    EMPIRE STATE BUILDING

	Name:       ARDFR_AurelienTourFpwmLed.ino.ino
    Created:	22.05.2021
    Author:     jpbbricole

	Version 0.5 Indexation des éléments et intégration SoftPwm
	Version 0.6 Ligne de commandes
	Version 0.7 Couleurs 24 bits
	Version 0.8 Commandes individuelles et commandes COB, COH, OBS et ALL
	Version 0.8 Calendrier à 5 tâches
	Version 0.9 Sonde lumière
'*------------------------------------------------------------------------
*/
#include <Wire.h>
#include <SoftPWM.h>            // https://github.com/bhagman/SoftPWM     https://github.com/bhagman/SoftPWM
#include <DS3231.h>             // https://www.arduinolibraries.info/libraries/ds3231
#include <SoftwareSerial.h>     // https://github.com/PaulStoffregen/SoftwareSerial

/*-----------------------------------------------------------------------
	Numérotation des séries et couleurs des LED PWM
	dans un tableau à 2 dimensions serCoulPin[][]
	Les séries sont numérotées par
	Les couleurs sont numérotées par
'*------------------------------------------------------------------------
*/
enum seriesIndex {serCornBas, serCornHaut, serObserv, serAntiCol, seriesNombre};
enum couleursIndex {coulRouge, coulVert, coulBleu, couleursNombre};

//------------------------------------- Tableau des pin des LED
const byte serCoulPin[][couleursNombre] =
	{
		{11, 10, 9},    // Corniche Bas
		{ 8,  7, 4},    // Corniche Haut
		{ 6,  5, 3},    // Observatoire
		{ 2,  2, 2},    // Anti-collision
	};

//------------------------------------- Tableau des intensité des LED, par couleur RGB
byte serCoulIntens[seriesNombre][couleursNombre];

const int ledPwmEtatBas = SOFTPWM_INVERTED; // ou SOFTPWM_NORMAL      // Pour SoftPwm etat quand PWM = 0 (defaultPolarity)

unsigned long serAffTimer = millis();
unsigned long serAffTime = 1000;     // Affichage des séries toutes les secondes

//------------------------------------- Feu anti-collision
int antiColCoulIntensite = 150;
int antiColFlashPeriode = 600;
unsigned long antiColAffTimer = millis();
unsigned long antiColAffTime = 2*antiColFlashPeriode;

//------------------------------------- Horloge RTC
DS3231 rtc;
unsigned long rtcScanTimer = millis();
unsigned long rtcScanTime = 1000;
const boolean rtcNowHHMM = true;     // Pour temps avec uniquement HHMM

//--------------------------------- Calendrier (cal)
#define calNombre 5     // Nombre d' entrées max dans le calendrier
const bool calTaskExec = true;     // Si tâche executée
struct calEntreeDef                           // VAriables avec _S font partie du setup
{String time; boolean execute;};
calEntreeDef cal[calNombre];     // Calendrier

//------------------------------------- Sonde lumière (lum)
const boolean lumEtatHaut = true;

struct sondeLumiereDef                           // VAriables avec _S font partie du setup
{int etat; int etatStable; int valeur; int valeurSeuil; int changeTimeSec; unsigned long changeTimer;};
sondeLumiereDef lum;                        // Aiguille en utilisation

#define lumSenorPin A3
int lumValeur = 0;

//------------------------------------- Liaison Bluetooth
SoftwareSerial btSerial(A1, A2); // RX, TX
bool btCmdRecue = false;         // Si une nouvelle commande a été reçue
String btTexte = "";             // Texte de la commande

//------------------------------------- Ligne de commandes
bool cmdNouvelleRecue = false;      // Si une nouvelle commande a été reçue
String cmdTexte = "";               // Texte de la commande

void setup() 
{
	Serial.begin(115200);
	btSerial.begin(9600);
	Wire.begin();

	//--------------------------------- Initialisation sonde lumière
	lum.valeurSeuil = 600;
	lum.changeTimeSec = 5;     // La lumière doit changer au moins x secondes
	lum.changeTimer = 0;
	// Aligner à la situation lumière de départ
	lumEtatMesure();
	lum.etatStable = lum.etat;
	lumChangeAction(lum.etatStable);
	
	//--------------------------------- Initialisation des PWM
	SoftPWMBegin(ledPwmEtatBas);
	
	for (int s = 0; s < seriesNombre; s++)
	{
		for (int c = 0; c < couleursNombre; c++)
		{
			SoftPWMSet(serCoulPin[s][c], 0);
		}
	}
	
	SoftPWMSetFadeTime(serCoulPin[serAntiCol][coulRouge], antiColFlashPeriode, antiColFlashPeriode);
	antiColAffichage();
	
	//--------------------------------- Initialisation du calendrier  time = "-" pour désactiver
	cal[0].time = "16:43"; cal[0].execute = !calTaskExec;
	cal[1].time = "01:15"; cal[1].execute = !calTaskExec;
	cal[2].time = "7"; cal[2].execute = !calTaskExec;
	cal[3].time = "31"; cal[3].execute = !calTaskExec;
	cal[4].time = "16:42"; cal[4].execute = !calTaskExec;
	//--------------------------------- Initialisation des séries
	//                                  https://www.toutes-les-couleurs.com/code-couleur-html.php
	cmdExecute("COB=00561B"); // Corniche Basse Vert impérial
	cmdExecute("COH=26C4EC"); // Corniche Haute Bleu céleste
	//cmdExecute("OBS=EFD242"); // Observatoir Jaune auréolin (Réglé par sonde lumière)
}

void loop()  
{
	//--------------------------------- Ecoute du port BT
	btSerialEvent();    
	if (btCmdRecue)      // Si une nouvelle commande depuis BT
	{
		Serial.print(F("Recption Bluetooth ")); Serial.println(btTexte);
		cmdExecute(btTexte);
		
		btTexte = "";
		btCmdRecue = false;
	}
	//--------------------------------- Ecoute du port serie
	//serialEvent();           // Enlever le commentaire si l'appel ne se fait pas automatiquement
	if (cmdNouvelleRecue)      // Si une nouvelle commande depuis le moniteur
	{
		cmdExecute(cmdTexte);
		
		cmdTexte = "";
		cmdNouvelleRecue = false;
	}

	//--------------------------------- Si temps pour afficher les séries
	if (millis()-serAffTimer >= serAffTime)     
	{
		serAffichage();
		serAffTimer = millis();

//		lumMesure();	// Enlever la remarque en cas d'usage de la sonde lumière	
	}
	//--------------------------------- Si temps pour afficher le feux anti-collision
	if (millis()-antiColAffTimer >= antiColAffTime)     
	{
		antiColAffichage();
		antiColAffTimer = millis();
	}

	//--------------------------------- RTC
	if (millis()-rtcScanTimer >= rtcScanTime)
	{
		//Serial.println(rtcNowToStr(!rtcNowHHMM));
		calScan();
		rtcScanTimer = millis();
	}
}

void antiColAffichage()
{
	static boolean displUp;
	
	if (displUp)
	{
		SoftPWMSet(serCoulPin[serAntiCol][coulRouge], antiColCoulIntensite);
	} 
	else
	{
		SoftPWMSet(serCoulPin[serAntiCol][coulRouge], 0);
	}
	displUp = !displUp;
}
//------------------------------------- Séries affichage
void serAffichage()
{
	// Commande des couleurs sur les 3 étages :

	// Observatoire (1)
	SoftPWMSet(serCoulPin[serObserv][coulRouge], serCoulIntens[serObserv][coulRouge]);  // Rouge (R)
	SoftPWMSet(serCoulPin[serObserv][coulVert], serCoulIntens[serObserv][coulVert]);    // Vert (G)
	SoftPWMSet(serCoulPin[serObserv][coulBleu], serCoulIntens[serObserv][coulBleu]);    // Bleu (B)

	//Corniche Haut (2)
	SoftPWMSet(serCoulPin[serCornHaut][coulRouge], serCoulIntens[serCornHaut][coulRouge]);  // Rouge (R)
	SoftPWMSet(serCoulPin[serCornHaut][coulVert], serCoulIntens[serCornHaut][coulVert]);    // Vert (G)
	SoftPWMSet(serCoulPin[serCornHaut][coulBleu], serCoulIntens[serCornHaut][coulBleu]);    // Bleu (B)

	//Corniche Bas (3)
	SoftPWMSet(serCoulPin[serCornBas][coulRouge], serCoulIntens[serCornBas][coulRouge]);   // Rouge (R)
	SoftPWMSet(serCoulPin[serCornBas][coulVert], serCoulIntens[serCornBas][coulVert]);     // Vert (G)
	SoftPWMSet(serCoulPin[serCornBas][coulBleu], serCoulIntens[serCornBas][coulBleu]);     // Bleu (B)
}

void serCouleurChange(int serIndex,long coul24bits)
{
	serCoulIntens[serIndex][coulRouge] = coul24bits >> 16;
	serCoulIntens[serIndex][coulVert] = coul24bits >> 8;
	serCoulIntens[serIndex][coulBleu] = coul24bits;
}

/*-----------------------------------------------------------------------
	Réception de commandes depuis Bluetooth
'*------------------------------------------------------------------------
*/
String rtcNowToStr(bool nowHHMM)
{
	bool h12Flag;
	bool pmFlag;
	String retVal = "";
	
	retVal = rtcNumSize2(rtc.getHour(h12Flag, pmFlag)) + ":" + rtcNumSize2(rtc.getMinute());
	if (!nowHHMM)
	{
		retVal +=":" + rtcNumSize2(rtc.getSecond());
	}
	 
	return retVal;
}
String rtcNumSize2(int number)
{
	return number < 10 ? "0" + String(number) : String(number);
}

/*-----------------------------------------------------------------------
	Calendrier (cal) les entrées peuvent être:
	16:43	tout les jours à 16:43
	1:15	à 01:15, 11:15, 21:15 ...
	01:15	tout les jours à 01:15
	31		à 00:31, 01:31, 02:31 ...
	7		à 00:07, 00:17, 00:27, 00:37 ... 12:07, 12:17...
'*------------------------------------------------------------------------
*/
//------------------------------------- Lecture du calendrier
void calScan()
{
	String timeCheck = rtcNowToStr(rtcNowHHMM);
	
	for (byte c = 0; c < calNombre; c++)
	{
		int timeL = cal[c].time.length();     // Longueure de time
		if (timeL >= 1)        // Si time valide
		{
			String timeCheckB = timeCheck.substring(timeCheck.length()-timeL);
			if (cal[c].time == timeCheckB && !cal[c].execute)    // Si tâche à échéance et pas executée
			{
				calTaskExecute(c);
				cal[c].execute = calTaskExec;     //     Tâche executée
			} 

		if (cal[c].time != timeCheckB && cal[c].execute)    // Si tâche à échéance et pas executée
		{
			cal[c].execute = !calTaskExec;     //     Libérer la tâche
		}
		}
	}
}
//------------------------------------- Calerndrier, exécution de la tâche
void calTaskExecute(byte taskIndex)
{
	Serial.print(F("\nCalendrier tache ")); Serial.print(String(taskIndex));
	Serial.println("\t" + rtcNowToStr(!rtcNowHHMM));

	switch (taskIndex)
	{
		case 0:
			cmdExecute("COB=26C4EC"); 
			break;
		case 1:
			cmdExecute("OBS=000000");    // Observatoir èteint
			break;
		case 2:
			cmdExecute("ALL=0000FF"); // Tout en bleu
			break;
		case 3:
			cmdExecute("ALL=FF0000"); // Tout en rouge
			break;
		case 4:
			cmdExecute("ALL=00FF00"); // Tout en vert
			break;
	}
}

/*------------------------------------------------------------------------------
	Sonde Luminosité 
	lumMesure() pour éviter le "pompage" dans le changement d'etat haut bas
	doit durer au moins lum.changeTimeSec secondes
'*------------------------------------------------------------------------------
*/
void lumMesure()
{
	lumEtatMesure();

	if (lum.etat != lum.etatStable)  // Si changement d'état
	{
		//Serial.println("PAS Egal");
		if (lum.changeTimer == 0)   // S'il n'y a pas déjà une transition en route
		{
			lum.changeTimer = millis();
			Serial.println("Chrono");
		}
	}
	else
	{
		//Serial.println("Egal");
		lum.changeTimer = 0;
	}
	
	if (lum.changeTimer != 0 && (millis()-lum.changeTimer >= lum.changeTimeSec*1000))
	{
		lum.etatStable = lum.etat;
		lum.changeTimer = 0;
		lumChangeAction(lum.etatStable);
	}

	if (lum.changeTimer != 0)  // Si timer en marche
	{
		Serial.print(F("Lum Timer ")); Serial.print((millis()-lum.changeTimer)/1000 +1); Serial.println(F("sec."));
	}
}

void lumEtatMesure()
{
	lum.valeur = analogRead(lumSenorPin);
	lum.etat = lum.valeur > lum.valeurSeuil ? lumEtatHaut : !lumEtatHaut;
}

void lumChangeAction(boolean etat)
{
	Serial.print(F("Action lumiere Etat "));
	
	if (etat == lumEtatHaut)
	{
		Serial.println(F("Haut"));
		cmdExecute("OBS=0000FF");
	}
	else
	{
		Serial.println(F("Bas"));
		cmdExecute("OBS=FF0000");
	}
}
/*---------------------------------------------------------------------------
	Ligne de commandes, le format est la commande = le paramètre
	ALL=FF00FF pour Fuchsia
	Ce système n'est pas sensible à la casse.

	Commandes acceptées
	
	ALL pour toutes les séries, couleurs 24 bits avec valeur en hexadécimal comme 00FF00 pour Vert
	COB pour Corniche Haute (24 bits)
	COH pour Corniche Basse (24 bits)
	OBS pour Observatoire (24 bits)
	https://htmlcolorcodes.com/fr/
	https://www.toutes-les-couleurs.com/code-couleur-html.php
'*----------------------------------------------------------------------------
*/
void cmdExecute(String cmdRx)
{
	String cmdParam = "";
	
	cmdRx.toUpperCase();                    // Tout en majuscules
	cmdRx.replace(" ", "");                 // Supprimer les espaces

	int sepPos = cmdRx.indexOf("=");        // Recherche du séparateur
	if (sepPos > -1)                        // Si séparateur trouvé
	{
		cmdParam = cmdRx.substring(sepPos +1);
		cmdRx = cmdRx.substring(0, sepPos);
	} 

	 // Pour convertir la String (FF00FF) en Hexa en variable long (Ne fait pas partie de la référence Arduino)
	long cmdParamLong = strtol(cmdParam.c_str(), NULL, 16);

	bool cmdOk = true;
	
	if (cmdRx == "COB")     // Cornière Bas
	{
		serCouleurChange(serCornBas, cmdParamLong);
	}
	else if (cmdRx == "COH")     // Cornière Haut
	{
		serCouleurChange(serCornHaut, cmdParamLong);
	}
	else if (cmdRx == "OBS")     // Observatoire
	{
		serCouleurChange(serObserv, cmdParamLong);
	}
	else if (cmdRx == "ALL")     // RGB en 24 bits
	{
		serCouleurChange(serCornBas, cmdParamLong);
		serCouleurChange(serCornHaut, cmdParamLong);
		serCouleurChange(serObserv, cmdParamLong);
	}
	else if (cmdRx == "CALAND")     // Calendrier task 4
	{
		cal[4].time = cmdParam; cal[4].execute = !calTaskExec;
		Serial.println(cal[4].time);
	}
	else
	{
		Serial.print(F("Commande inconnue ")); Serial.println(cmdRx);
		cmdOk = false;
	}
	if (cmdOk)     // Si la commande est valide
	{
		Serial.print(F("Commande OK ")); Serial.println(cmdRx + " " + cmdParam);
	}
}

/*-----------------------------------------------------------------------
	Réception de commandes depuis Bluetooth
'*------------------------------------------------------------------------
*/
void btSerialEvent()                                       
{
	while (btSerial.available())
	{
		char monChar = (char)btSerial.read();     // Char received from IDE monitor
		if (monChar == '\n')                      // If new line char received = end of command line
		{
			btCmdRecue  = true;
		}
		else
		{
			if (monChar >= ' ') {btTexte += monChar;}     // >= ' ' to avoid not wanted ctrl char.
		}
	}
}

/*-----------------------------------------------------------------------
	Réception de commandes depuis le moniteur
'*------------------------------------------------------------------------
*/
void serialEvent()                                       
{
	while (Serial.available())
	{
		char monChar = (char)Serial.read();     // Char received from IDE monitor
		if (monChar == '\n')                    // If new line char received = end of command line
		{
			cmdNouvelleRecue  = true;
		}
		else
		{
			if (monChar >= ' ') {cmdTexte += monChar;}     // >= ' ' to avoid unwanted ctrl char.
		}
	}
}

A toi de jouer!

A+
Cordialement
jpbbricole

Non ! Comment pourrais-je la connaitre ?
Effectivement, s'il existe un tuto ça me facilitera la tâche, mais je peux explorer par moi-même sinon (tu as déjà passé beaucoup de temps sur ce projet !)

Je ne m'étais jamais posé la question donc j'ai pesé ! Résultat : 3,3kg ! J'aurais dit plus (bon c'est quasiment vide à l'intérieur !)

Avec plaisir !

Quel serait le but exactement ? Des klaxons de taxi ? Ahahah

Ok, je vais essayer dès ce soir. Mais que veut dire 5 tâches ? Qu'on peut lui donner 5 types de temporalité différentes ? Je ne sais pas comment l'exprimer mais genre Année, mois, jour, heure, minute... ?

Quelle est cette sonde ? A quoi sert-elle exactement ?

Donc en fonction de la valeur, ça va du rouge au bleu en passant par le vert si la valeur est intermédiaire c'est ça ?

J'ai parcouru le code, c'est impressionnant ! (en tout cas pour moi). Je vais l'utiliser ce soir et essayer de comprendre en même temps :grinning_face_with_smiling_eyes:

Merci !

Bonjour Aurélien

Bon, en général, c'est 9600, mais je te ferais un petit bout de programme pour tester tout ça.
Pour la connexion au UNO:
BT TXD sur UNO A1
BT RXD sur UNO A2
Je te ferais un petit tuto autant du côté Android que du côté UNO.

Comme tu as demandé des changements de couleurs quotidiens, pour ça, tu as 5 programmes (0-4) possibles comme l'exemple qui est mis au départ du programme. A toi de mettre d'autres changements de couleurs.

//--------------------------------- Initialisation du calendrier  time = "-" pour désactiver
	cal[0].time = "16:43"; cal[0].execute = !calTaskExec;
	cal[1].time = "01:15"; cal[1].execute = !calTaskExec;
	cal[2].time = "7"; cal[2].execute = !calTaskExec;
	cal[3].time = "31"; cal[3].execute = !calTaskExec;
	cal[4].time = "16:42"; cal[4].execute = !calTaskExec;

//------------------------------------- Calerndrier, exécution de la tâche
void calTaskExecute(byte taskIndex)
{
	Serial.print(F("\nCalendrier tache ")); Serial.print(String(taskIndex));
	Serial.println("\t" + rtcNowToStr(!rtcNowHHMM));

	switch (taskIndex)
	{
		case 0:
			cmdExecute("COB=26C4EC"); 
			break;
		case 1:
			cmdExecute("OBS=000000");    // Observatoir èteint
			break;
		case 2:
			cmdExecute("ALL=0000FF"); // Tout en bleu
			break;
		case 3:
			cmdExecute("ALL=FF0000"); // Tout en rouge
			break;
		case 4:
			cmdExecute("ALL=00FF00"); // Tout en vert
			break;
	}
}

Il y a d'autres informations sur ce calendrier, dans les remarques du programme.

C'était pour titlller l'imagination du bricoleur que tu est!!!

C'était pour répondre à cette question:

Actuellement, à un certain changement, il se passe ceci:

if (etat == lumEtatHaut) { Serial.println(F("Haut")); cmdExecute("OBS=0000FF"); } else { Serial.println(F("Bas")); cmdExecute("OBS=FF0000"); }
Qui est un changement de lumière à l'observatoire, mais ça peut être changé, on peut inventer de nouvelles actions.

Une petite remarque, comme tu n'as pas encore cette sonde connectée au UNO il serait bien de mettre en remarque cette ligne du programme, pour éviter que cette entrée "en l'air" ne perrtube.
Dans loop()

//		lumMesure();		

Actuellement, il y a une action uniquement à un changement de seuil défini
lum.valeurSeuil = 600; // A calibrer
mais on pourrais très bien convertir un degré de lumière en couleur, si tu le veux...
Dès que j'ai un peu de temps, je te ferais une petite démo.

A+
Cordialement
jpbbricole

Bonjour Aurélien

Pour le fun!, le projet sur lequel je gamberge, actuellement

Ce système, articulé sur un bus i2C, sert à commander une « machine GRBL (10)» qui commande une CNC, avec lecture de règles électroniques sur les 4 axes de la machine.
Toutes les communications se font en i2C sauf la liaison 1>10 qui se fait par ports série à 115 200.

  1. Processeur central (MM), master du bus i2C, avec interface Bluetooth.
  2. Pupitre additionnel (PADD) sur lequel sont connecté un codeur rotatif, pour la gestion des menus sur l’affichage LCD, 2 joystick pour les déplacements manuels des axes X, Y, Z et A ainsi que quelques boutons de fonctions. Toutes ces données sont lues, périodiquement, par MM, via le bus i2C.
  3. Interface pour 1 règle magnétique de type AS5000-MS20 ou un codeur rotatif
  4. Interface pour 2 pieds à coulisse (PAC) « chinois »
  5. Interface pour 2 règles Shahe
  6. Ecran LCD 20x4
  7. LED de signalisation de type WS2812
  8. BUS i2C
  9. Rien
  10. Machine GRBL 4 axes X, Y, Z et A
  11. Emulateur de moteur pas à pas (MPAP) avec une visualisation des mouvements des MPAP au moyen de LED WS2812 (C’est moins bruyant que des NEMAxx !).

A+
Cordialement
jpbbricole

projet ambititieux !! :slight_smile:

  • attention aux masses, on dirait qu'elles vont de proche en proche, il vaut mieux généralement les câbler en étoile (surtout quand il y aura des moteurs autour du montage)
  • je suis curieux sur l'interface de vos pieds à coulisse. Vous avez un lien sur ces outils avec sortie numérique ? (ou c'est un hack ?). Avez vous besoin de dédier un arduino à chacun ou c'est juste un choix pour la modularité ?

Bonjour J-M-L

C'est un montage assez courant sur Arduino, ces chinese calipers sont compatible pour autant qu'ils aient une petite porte sur le dessus pour pouvoir souder ou mieux imprimer un petit connecteur. En plus ils coûtent trois fois rien!

C’est pour la modularité. Il peut y avoir 2 appareil de mesure par module, pour autant qu’il n’emploient qu’un interrupt chacun, on peut, ainsi mettre 2 PAC ou 2 règles Shahe, par contre pour les règles magnétiques ou les codeurs incrémentaux en quadrature, il faut 2 interrupt pour en tirer le maximum.

Le programme des modules est « universel » et se programme par commandes, selon mon habitude.
On y programme le type d’appareil ainsi que son adresse sur le bus i2C.
Chaque module a un pseudo et une liste de commandes possible comme LEDrgb, ainsi depuis la master i2C (Mega) on peut envoyer une commande à PACCN (pour pac chinois) ainsi :PACC>LED rgb=017, pour allumer la LED 0 couleur verte puissance 7/10. L’échange de données sur le bus i2C se fait par des données mises en structure.
Ici il y a quelques exemples de ce genre d’utilisation des pac chinois (il faut trier :wink:).

Cordialement
Jpbbricole

ah cool, j'ai un Fischer Darex et je n'avais jamais remarqué la petite trappe :slight_smile:


ça donne des idées d'exploration :slight_smile:

sympa votre projet en tout cas

Bonjour J-M-L

Dernière "pollution" du fil d'Aurélien, excuses!

Voilà mon schéma du module d'adaptation des PAC chinois à l'Arduino


Les signaux PACCNA_CLK' et PACCNB_CLK' sont connectés, respectivement, aux pin 2 et 3 de l'Arduino.

Bonne après-midi
Cordialement
jpbbricole

Sympa - merci

--> un autre tuto pour vous à écrire sur le montage et le code :wink:

(fin de la pollution)

Bonjour Aurélien

Petite question en vue d'un tuto "comment commander ma tour depuis mon smartphone", est tu à l'aise avec le paramètrage/apairage bluetooth.?
Pour les HC-06 la clef est 1234

Cordialement
jpbbricole

Bonjour Aurélien

Je te mets un petit tuto comment mettre en marche le Bluetooth (BT) entre le smartphone et l'application de la tour:

Connexion du module HC-06
BT TXD sur UNO A1
BT RXD sur UNO A2

Dans le smartphone, installer l’application Serial Bluetooth Terminal

image
Lancer l’application, on se retrouve avec une série de boutons M1, M2, M3…
Pour configurer M1, presser dessus ~3 sec. Et le remplir comme suit :
image
COBrou
COB=FF0000

Faire la même chose avec M2 :
image
COBver
COB=00FF00

Et puis avec M3 :
image
COBble
COB=0000FF

A la fin on devrait avoir :
image
Il pourrait y avoir plusieurs lignes de boutons, ça dépend de la configuration de départ.

Il faut sélectionner le BT HC-06 en glissant l’écran depuis la gauche et choisissant Devices, il devrait y avoir le HC-06 avec une barre verte à gauche. Cliquer dessus. Connecter l’application au HC-06 par
image
et le texte Connecting to HC-06
qui devient
image
avec le texte Connected. La LED du module BT devrait cesser de clignoter ou clignoter moins fréquemment.

La liaison avec le module BT est établie.
Pour faire l’essai et, surtout déterminer la vitesse du module BT (en général à 9600, au départ), il faut charger ce petit bout de programme :

/*
    Name:       ARDFR_AurelienTestBt.ino
    Created:	03.06.2021
    Author:     jpbbricole
*/
#include <SoftwareSerial.h>     // https://github.com/PaulStoffregen/SoftwareSerial
//------------------------------------- Liaison Bluetooth
SoftwareSerial btSerial(A1, A2); // RX, TX
bool btCmdRecue = false;         // Si une nouvelle commande a été reçue
String btTexte = "";             // Texte de la commande

//------------------------------------- Ligne de commandes
bool cmdNouvelleRecue = false;      // Si une nouvelle commande a été reçue
String cmdTexte = "";               // Texte de la commande

void setup() 
{
	Serial.begin(115200);
	btSerial.begin(9600);
}

void loop()  
{
	//--------------------------------- Ecoute du port BT
	btSerialEvent();    
	if (btCmdRecue)      // Si une nouvelle commande depuis BT
	{
		Serial.print(F("Recption Bluetooth ")); Serial.println(btTexte);
		
		btTexte = "";
		btCmdRecue = false;
	}
	//--------------------------------- Ecoute du port serie
	//serialEvent();           // Enlever le commentaire si l'appel ne se fait pas automatiquement
	if (cmdNouvelleRecue)      // Si une nouvelle commande depuis le moniteur
	{
		Serial.println(btTexte);
		
		cmdTexte = "";
		cmdNouvelleRecue = false;
	}
}

/*-----------------------------------------------------------------------
	Réception de commandes depuis Bluetooth
'*------------------------------------------------------------------------
*/
void btSerialEvent()                                       
{
	while (btSerial.available())
	{
		char monChar = (char)btSerial.read();     // Char received from IDE monitor
		if (monChar == '\n')                      // If new line char received = end of command line
		{
			btCmdRecue  = true;
		}
		else
		{
			if (monChar >= ' ') {btTexte += monChar;}     // >= ' ' to avoid not wanted ctrl char.
		}
	}
}

/*-----------------------------------------------------------------------
	Réception de commandes depuis le moniteur
'*------------------------------------------------------------------------
*/
void serialEvent()                                       
{
	while (Serial.available())
	{
		char monChar = (char)Serial.read();     // Char received from IDE monitor
		if (monChar == '\n')                    // If new line char received = end of command line
		{
			cmdNouvelleRecue  = true;
		}
		else
		{
			if (monChar >= ' ') {cmdTexte += monChar;}     // >= ' ' to avoid unwanted ctrl char.
		}
	}
}

Avec le moniteur à 115200, la liaison BT est à 9600.
En pressant sur les boutons M1 ou M2 ou M3, on doit voire, dans le moniteur, respectivement
Recption Bluetooth COB=FF0000
Recption Bluetooth COB=00FF00
Recption Bluetooth COB=0000FF

S’il n’y a rien ou des signes cabalistiques, jouer avec
btSerial.begin (9600);
Si tu veux changer le nom et ou la vitesse, il y a plein de tutos sur Internet.

Une fois le test réussi, recharger l’application principale et refaire les tests M1, M2, M3, la Corniche Basse devrait passer du rouge, au vert puis au bleu.

A+
Cordialement
jpbbricole
AurelienTutoBt.pdf (604.1 KB)

Bonsoir J-M-L

Encore un presque hors sujet. J'ai du faire un petit tuto sur cette "mécanique" Excel<> Arduino concernant une commande de moteur pas à pas, pour que tu aies une idée, je te fournis un zip du projet, c'est un tout premier jet!

Cordialement
jpbbricole
DRO Mpap Console XLS Kit.zip (312.6 KB)

Bonsoir JML
on retrouve assez souvent ce type de connecteur sur des pieds à coulisses /comparateurs
image

Merci (comme je suis sur Mac, ActiveX n'est pas supporté)

Bonjour à tous !

Désolé de l'absence, beaucoup de boulot comme annoncé... J'essaie de me mettre à jour de tes messages aujourd'hui. Merci beaucoup pour ces nombreuses indications !

Ahah pas de problème, je comprends peu de choses mais c'est intéressant !

- Ce qui a marché :

ça c'est ok ! J'ai fait un truc bien propre (en fait, tout ce qui est bricolage et branchement, je maitrise très bien !)

J'ai réussi à connecter la tour à mon smartphone via l'appli. Merci du tuto !

- Les points de blocages :

Il commence a y avoir beaucoup d'éléments dans le codage et je crois que perds un peu le fil :

  • Pour le moment, je n'ai pas de sonde de luminosité
  • J'ai changé les parties du code qui était à modifier, mais je ne pense pas avoir réussi car j'ai des messages d'erreurs :frowning:

ça, c'est bon. je crois que j'ai capté, tous les "14h27, 14h37, etc.", il change de couleur.

Mais pour paramétrer ces couleurs, je ne crois pas avoir compris (j'ai testé des trucs qui n'ont visiblement pas marché :laughing:) C'est loin de mon premier code très simpliste RGB :grinning_face_with_smiling_eyes:

Si nous partons du principe que tous les jours à 12h00, le trio de couleur change. Dois-je définir le calendrier précis dans le code (ce serait lourd non ?)

Désolé de mon incompétence ! Et merci beaucoup pour le temps passé

Bonjour Aurélien

Pas de soucis, j’ai d’autres choses pour m’occuper :wink:

Alors là ! je te comprends, ton projet est exactement le genre de truc qui m’emballe, alors je fonce. N’hésites surtout pas à tirer le frein à main !

Super, ça donne confiance!

Quelles parties du code as-tu changé ? Quels sont les messages d’erreurs ?
Il suffisait de charger le programme de test du post #92 et de faire des essais avec ton smartphone.

Actuellement, le système est assez « simpliste » , c'est-à-dire que les actions du calendrier sont « fixées » dans le programme, l’assouplissement de ceci sera la prochaine étape.
Je te ferais une programmation exemple pour que tu puisses comprendre mon système.

A+

Cordialement
jpbbricole

Ok, je n'avais pas compris cela (j'ai essayé de l'intégrer dans les programmes précédents ! :man_facepalming:)

J'ai fait comme tu m'as dit, c'est passé, et effectivement, dans le moniteur, j'ai des messages comme cela :

Je crois que c'est ce que tu appelles des "signes cabalistiques" ? A ce moment, tu disais qu'il fallait "jouer avec btSerial.begin (9600);".

J'ai fait ça (tout en changeant dans le moniteur = "115200 baud") :

et j'ai ça dans la moniteur :

Mais quand j'ai recommencé, plus rien ne s'affichait dans le moniteur :thinking:

Cool merci :grinning_face_with_smiling_eyes:
J'ai un module pour l'arduino avec un port Carte SD, je ne sais pas si ça peut servir... Est-ce que un programme arduino peut aller lire un fichier sur une carte SD dans lequel il y a la planification des couleurs ?

Bonsoir Aurélien

Pas tout à fait, puisqu'une partie du message est juste? Bizarre! Est-ce-que tes GND sont bien connectés ensembles?

Quand tu recommences quoi? Est-ce qu'après un reset de l'Arduino, ça refonctionne?
Réessaies avec les 2 vitesses en faisant un reset chaque fois.

Oui, bien sûre, mais, alors là tu me cherches :blush:.
Mais, pour ça, il faudrait passer au Mega. A étudier.

A+
Cordialement
jpbbricole

J'ai 3 GND connectés (voir schéma à jour ci-après) :

  • Un pour les bandes RGB, la led RGB et une led rouge
  • Un pour les deux modules
  • Un pour l'alimentation

J'ai recommencé, j'ai fait ceci :

Et j'ai eu ça dans le moniteur en actionnant les boutons M1 à M3 configurés :

Le problème ne semble donc pas se reproduire, je ne comprends pas bien pourquoi

D'un point de vu débutant, j'essaie de rester naïvement simpliste :laughing: en passant par un bête fichier qui listerait toutes les dates et les couleurs au jour le jour, mais ce n'est pas moi le spécialiste !

Bonsoir Aurélien

Super, tu deviens une bête!!
Maintenant, tu peux recharger le programme principal et pouvoir changer les couleurs de la corniche bas depuis ton smartphone.

Ce sera pour plus tard, quand tu aura assimilé le programme actuel.

A+
Cordialement
jpbbricole