IOT123 - TRACKER SOLAIRE - CONTRLEUR : 8 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:09

Il s'agit d'une extension de l'Instructable

IOT123 - TRACKER SOLAIRE - TILT/PAN, PANNEAU CADRE, LDR MONTE RIG. Ici, nous nous concentrons sur le contrôleur des servos et les capteurs de la position du soleil. Il est important de souligner que cette conception suppose que 2 MCU seront utilisés: un (3,3 V 8 mHz Arduino Pro Mini) pour le tracker solaire et un MCU indépendant pour vos capteurs/acteurs.

Il s'agit de la version 0.3

Plutôt que de publier tous les projets après une entière satisfaction, je vais pratiquer l'intégration continue et livrer quelque chose plus souvent, en modifiant ce que j'ai livré selon mes besoins. J'écrirai une autre instructable pour le chargeur de batterie, _quand_ l'optimisation du logiciel/matériel du contrôleur est terminée. Je soulignerai où les optimisations sont nécessaires au fur et à mesure que nous avançons dans cette étape.

Une partie de la raison de cette approche est la rétroaction des clients. Si vous voyez un besoin ou avez une meilleure approche, veuillez commenter, mais gardez à l'esprit que je ne peux pas tout livrer et peut-être pas dans un délai qui vous convient. Ces explications semblant moins pertinentes, elles seront supprimées de cet article.

Ce que cela comprend:

1. Utilisez les LDR de l'Instructable d'origine pour détecter l'emplacement approximatif des soleils.
2. Déplacez les servos pour faire face au soleil.
3. Options pour la sensibilité des mouvements.
4. Options pour la taille du pas lors du déplacement vers le soleil.
5. Options pour les contraintes angulaires utilisées sur les servos.
6. Options pour les retards des mouvements.
7. Interface I2C pour définir/obtenir des valeurs entre les MCU.
8. Sommeil profond entre les mouvements.

Ce que cela n'inclut pas (et sera traité si le temps le permet):

1. Utiliser l'électricité uniquement pendant les heures de clarté.
2. Se souvenir de la position de l'aube et s'y rendre au crépuscule.
3. Retrait du régulateur du MCU.
4. Désactivation de la ou des LED sur le MCU.
5. Réacheminement de l'alimentation via VCC plutôt que RAW.
6. Fournir des solutions de contournement pour le flash sans alimentation régulée du convertisseur USB vers série TTL.
7. Moniteur de tension de batterie.

L'HISTOIRE

20 déc. 2017 V0.1 CODE

La version initiale suit la source lumineuse, toujours allumée, pas de charge

7 janv. 2018 V0.2 CODE

• CHANGEMENTS MATÉRIELS

  • Ajouter des broches I2C
  • Ajouter un commutateur aux servomoteurs GND
  • Étiquette imprimée sur le fascia du boîtier du contrôleur

• CHANGEMENTS LOGICIELS

  • Lire la configuration depuis l'EEPROM
  • Prise en charge du bus I2C en tant qu'esclave d'un autre MCU (3,3 V)
  • Définir la configuration via I2C
  • Définir activé via I2C
  • Obtenir la configuration via I2C
  • Obtenez les propriétés d'exécution via I2C (actuellement activé et intensité lumineuse actuelle)
  • Supprimer la journalisation série (cela a affecté les valeurs I2C)

19 janv. 2018 V0.3 CODE

• MATÉRIEL

  Étiquette mise à jour. Le commutateur est maintenant utilisé pour choisir le mode CONFIG ou TRACK

• LOGICIEL

  • I2C utilisé uniquement pour la configuration
  • Le contrôleur attend 5 secondes avant d'initialiser le suivi, permet de déplacer les mains
  • Pour utiliser la configuration I2C, SPDT doit être sur CONFIG lorsque l'unité démarre
  • Entre les mouvements de suivi, l'unité est en mode veille profonde pour la valeur de configuration SLEEP MINUTES (20 minutes par défaut).

Étape 1: Matériaux et outils

Il existe maintenant une liste complète de la nomenclature et des sources.

1. Pièces imprimées en 3D.
2. Arduino Pro Mini 3.3V 8mHz
3. 1 de 4x6cm Carte de Circuit Imprimé Universelle Prototype Double Face PCB (à couper en deux)
4. 1 connecteur mâle 40P (à couper sur mesure).
5. 1 connecteur femelle 40P (à couper sur mesure).
6. 4 résistances 10K 1/4W.
7. Brancher le fil.
8. Soudure et fer.
9. 20 vis autotaraudeuses à tête cylindrique en acier inoxydable 4G x 6 mm.
10. 4 vis autotaraudeuses à tête fraisée en acier inoxydable 4G x 6 mm.
11. 1 batterie LiPo 3,7 V et support (se terminant par des connecteurs dupont 2P).
12. 1 connecteur mâle à angle droit 2P
13. 1 commutateur SPDT à 3 broches au pas de 2,54 mm
14. Colle cyanoacrylate forte
15. Connecteurs Dupont femelle 1P en-tête (1 bleu, 1 vert).

Étape 2: Assemblage du circuit

Le circuit n'a actuellement pas de circuit diviseur de tension (voltmètre).

1. Coupez la carte de circuit imprimé universelle PCB Prototype double face 4x6cm en deux sur l'axe long.

2. Coupez le connecteur mâle 40P en morceaux:

   1. 2 hors 12P
   2. 3 hors 3P
   3. 6 hors 2P.

3. Coupez le connecteur femelle 40P en morceaux:

   1. 2 hors 12P
   2. 1 sur 6P
4. Soudez 2 en-tête 12Pfemale comme indiqué.
5. Collez l'entretoise retirée d'un connecteur mâle 3P (supplémentaire) sur la face inférieure du commutateur SPDT avec de la colle cyanoacrylate
6. De l'autre côté, soudez 6 connecteurs 2P, 2 connecteurs 3P mâle et le commutateur SPDT comme indiqué.
7. Soudez 4 résistances 10K (A, B, C, D noir) via un fil à l'en-tête de broche GND (n°2 noir) et aux broches d'en-tête A0 - A3 (n°5, #6, #7, #8) puis à travers le trou (jaune) comme indiqué (3 photos + 1 schéma).
8. Tracez 3,3 V à partir des broches LDR en soudant les broches n ° 4, n ° 6, n ° 8, n ° 10 et enfilez le trou jusqu'à la broche VCC de l'en-tête femelle (vert).
9. Tracez 3,3 V du côté de l'embase femelle comme indiqué (rouge) en soudant aux broches #1, #12, #15.
10. 3,3 V à travers le trou de la broche d'en-tête RAW n° 1 soudée sur le côté (rouge).
11. Tracez le branchement orange de la broche n°11 à travers le trou jusqu'à souder la broche femelle de l'autre côté, comme illustré.
12. Tracez et soudez le fil de raccordement bleu du #20 au #30 et du #31 au #13 et #16.
13. Soudez la broche femelle d'en-tête n°11 à la broche d'en-tête mâle n°11 à travers le trou.
14. Préparez 2 connecteurs dupont de 30 mm de long avec embase femelle 1P (1 bleu, 1 vert). Bande et étamer l'autre extrémité.
15. Souder le fil bleu Dupont au #28; souder le fil vert Dupont au #29.
16. Sur le dessus de l'Arduino, fixez l'en-tête femelle 6P puis soudez.
17. Sur le dessus de l'Arduino, fixez l'embase femelle à angle droit 2P int #29 et #30 puis soudez.
18. Sur le dessous de l'Arduino, fixez les 2 broches mâles 12P et 1 broches 3P puis soudez.
19. Insérez les broches mâles Arduino 12P dans les embases femelles PCB 12P.

Étape 3: Flasher le MCU

L'Arduino Pro Mini est flashé de manière pratique à l'aide d'un convertisseur FTDI232 USB vers TTL utilisant l'en-tête femelle 6P. Voir la photo ci-dessus pour l'alignement des 2 planches.

Assurez-vous que le paramètre 3.3V est choisi sur votre FTDI232. Suivez les instructions ici en utilisant le code ci-dessous (utilisez le lien vers GIST).

La bibliothèque basse consommation (ci-jointe et https://github.com/rocketscream/Low-Power) doit être installée.

Une fois que l'Arduino Pro Mini + PCB est installé dans le boîtier, il peut toujours être flashé car les broches de l'en-tête sont exposées. Déconnectez simplement l'unité de contrôle du cadre du panneau en exposant l'en-tête.

Tracker solaire à plateau basculant avec configuration I2C/EEPROM et cycle de veille entre les mouvements. La précision de la durée du cycle de sommeil diminue à mesure que la durée augmente, mais suffisante à cette fin

/*

* modifié à partir du code

* par Mathias Leroy

*

* MODIFICATIONS V0.2

** I2C SET GET

** EEPROM SET GET

** SUPPRIMER LA SORTIE SÉRIE - I2C AFFECTÉ

** ACTIVER/DÉSACTIVER LE SUIVI

** DÉPLACER LES SERVOS AUX LIMITES VIA I2C

** LIRE L'INTENSITÉ MOYENNE ACTUELLE VIA I2C

* MODIFICATIONS V0.3

** COMMUTATEUR POUR 2 MODES - TRACK (NO I2C) et CONFIGURE (USE I2C)

** SOMMEIL EN MODE PISTE (TRÈS FAIBLE PRÉCISION GRÂCE À 8 SECONDES CHUNKS)

** DÉTACHEZ/ATTACHEZ LES SERVOS SUR SOMMEIL/RÉVEIL (TRANSISTOR UTILISÉ ÉVENTUELLEMENT)

** SUPPRIMER LA POSITION INITIALE CONFIGURABLE (REDONDANTE)

** SUPPRIMER LES SECONDES DE RÉVEIL CONFIGURABLES (REDONDANTES)

** SUPPRIMER CONFIGURABLE ACTIVER/DÉSACTIVER (REDONDANT)

** SUPPRIMER LE TRACKER CONFIGURABLE ACTIVÉ (UTILISER LE COMMUTATEUR MATÉRIEL)

** ENLEVEZ LE GETTER DE TENSION - UTILISERA UN COMPOSANT I2C SÉPARÉ

** AJOUTER L'ENREGISTREMENT SERIE LORSQUE VOUS N'UTILISEZ PAS I2C

*/

#comprendre

#comprendre

#comprendre

#comprendre

#comprendre

#defineEEPROM_VERSION1

#defineI2C_MSG_IN_SIZE3

#definePIN_LDR_TL A0

#definePIN_LDR_TR A1

#definePIN_LDR_BR A3

#definePIN_LDR_BL A2

#definePIN_SERVO_V11

#definePIN_SERVO_H5

#defineIDX_I2C_ADDR0

#defineIDX_V_ANGLE_MIN1

#defineIDX_V_ANGLE_MAX2

#defineIDX_V_SENSITIVITY3

#defineIDX_V_STEP4

#defineIDX_H_ANGLE_MIN5

#defineIDX_H_ANGLE_MAX6

#defineIDX_H_SENSITIVITY7

#defineIDX_H_STEP8

#defineIDX_SLEEP_MINUTES9

#defineIDX_V_DAWN_ANGLE10

#defineIDX_H_DAWN_ANGLE11

#defineIDX_DAWN_INTENSITY12// moyenne de tous les LDRS

#defineIDX_DUSK_INTENSITY13// moyenne de tous les LDRS

#defineIDX_END_EEPROM_SET14

#defineIDX_CURRENT_INTENSITY15// moyenne de tous les LDRS - utilisé pour calculer IDX_DAWN_INTENSITY lumière ambiante non directe

#defineIDX_END_VALUES_GET16

#defineIDX_SIGN_117

#defineIDX_SIGN_218

#defineIDX_SIGN_319

Servo _servoH;

Servo _servoV;

octet _i2cVals[20] = {10, 10, 170, 20, 5, 10, 170, 20, 5, 20, 40, 10, 30, 40, 0, 0, 0, 0, 0, 0};

int _servoLoopDelay = 10;

int _slowingDelay=0;

int_angleH = 90;

int_angleV = 90;

int _averageTop = 0;

int _averageRight = 0;

int _averageBottom = 0;

int _averageLeft = 0;

octet _i2cResponse = 0;

bool _inConfigMode = false;

void setup()

{

Serial.begin(115200);

getFromEeprom();

if (inConfigMode()){

Serial.println ("Mode de configuration");

Serial.print("Adresse I2C: ");

Serial.println(_i2cVals[IDX_I2C_ADDR]);

Wire.begin(_i2cVals[IDX_I2C_ADDR]);

Wire.onReceive(receiveEvent);

Wire.onRequest(requestEvent);

}autre{

Serial.println("Mode de suivi");

délai (5000); // temps de se dégager les mains si vous connectez la batterie, etc.

}

}

boucle vide()

{

getLightValues();

si (!_inConfigMode){

// À faire: ACTIVER LE COMMUTATEUR DE TRANSISTOR

_servoH.attach(PIN_SERVO_H);

_servoV.attach(PIN_SERVO_V);

pour (int i = 0; i < 20; i++){

si (je != 0){

getLightValues();

}

moveServos();

}

retard (500);

_servoH.detach();

_servoV.detach();

// À faire: DÉSACTIVER LE COMMUTATEUR DE TRANSISTOR

retard (500);

endormiPour((_i2cVals[IDX_SLEEP_MINUTES] * 60) / 8);

}

}

//---------------------------------MODE ACTUEL

boolinConfigMode(){

pinMode(PIN_SERVO_H, ENTRÉE);

_inConfigMode = digitalRead(PIN_SERVO_H) == 1;

return _inConfigMode;

}

//---------------------------------EEPROM

voidgetFromEeprom(){

si(

EEPROM.read(IDX_SIGN_1) != 'S' ||

EEPROM.read(IDX_SIGN_2) != 'T' ||

EEPROM.read(IDX_SIGN_3) != EEPROM_VERSION

) EEPROM_write_default_configuration();

EEPROM_read_configuration();

}

voidEEPROM_write_default_configuration(){

Serial.println("EEPROM_write_default_configuration");

pour (int i = 0; i < IDX_END_EEPROM_SET; i++){

EEPROM.update(i, _i2cVals);

}

EEPROM.update(IDX_SIGN_1, 'S');

EEPROM.update(IDX_SIGN_2, 'T');

EEPROM.update(IDX_SIGN_3, EEPROM_VERSION);

}

voidEEPROM_read_configuration(){

Serial.println("EEPROM_read_configuration");

pour (int i = 0; i < IDX_END_EEPROM_SET; i++){

_i2cVals = EEPROM.read(i);

//Serial.println(String(i) + " = " + _i2cVals);

}

}

//---------------------------------I2C

voidreceiveEvent(int count) {

si (compte == I2C_MSG_IN_SIZE)

{

char cmd = Wire.read();

indice d'octet = Wire.read();

valeur d'octet = Wire.read();

commutateur (cmd) {

cas 'G':

si (index< IDX_END_VALUES_GET){

_i2cResponse = _i2cVals[index];

}

Pause;

cas 'S':

si (index< IDX_END_EEPROM_SET){

_i2cVals[index] = valeur;

EEPROM.update(index, _i2cVals[index]);

}

Pause;

défaut:

revenir;

}

}

}

voidrequestEvent()

{

Wire.write(_i2cResponse);

}

//---------------------------------LDR

voidgetLightValues(){

valeur intTopLeft = analogRead(PIN_LDR_TL);

valeur intTopRight = analogRead(PIN_LDR_TR);

valeur intBottomRight = analogRead(PIN_LDR_BR);

int valueBottomLeft = analogRead(PIN_LDR_BL);

_averageTop = (valueTopLeft + valueTopRight) / 2;

_averageRight = (valueTopRight + valueBottomRight) / 2;

_averageBottom = (valueBottomRight + valueBottomLeft) / 2;

_averageLeft = (valueBottomLeft + valueTopLeft) / 2;

int avgIntensity = (valueTopLeft + valueTopRight + valueBottomRight + valueBottomLeft) / 4;

_i2cVals[IDX_CURRENT_INTENSITY] = map(avgIntensity, 0, 1024, 0, 255);

}

//---------------------------------SERVOS

voidmoveServos(){

Serial.println("moveServos");

if ((_averageLeft-_averageRight)>_i2cVals[IDX_H_SENSITIVITY] && (_angleH-_i2cVals[IDX_H_STEP])>_i2cVals[IDX_H_ANGLE_MIN]) {

// va à gauche

Serial.println("moveServos va à gauche");

delay(_slowingDelay);

pour (int i=0; i < _i2cVals[IDX_H_STEP]; i++){

_servoH.write(_angleH--);

delay(_servoLoopDelay);

}

}

elseif ((_averageRight-_averageLeft)>_i2cVals[IDX_H_SENSITIVITY] && (_angleH+_i2cVals[IDX_H_STEP])<_i2cVals[IDX_H_ANGLE_MAX]) {

// va à droite

Serial.println("moveServos va à gauche");

delay(_slowingDelay);

pour (int i=0; i < _i2cVals[IDX_H_STEP]; i++){

_servoH.write(_angleH++);

delay(_servoLoopDelay);

}

}

autre {

// Ne rien faire

Serial.println("moveServos ne fait rien");

delay(_slowingDelay);

}

if ((_averageTop-_averageBottom)>_i2cVals[IDX_V_SENSITIVITY] && (_angleV+_i2cVals[IDX_V_STEP])<_i2cVals[IDX_V_ANGLE_MAX]) {

// en montant

Serial.println("moveServos qui monte");

delay(_slowingDelay);

pour (int i=0; i < _i2cVals[IDX_V_STEP]; i++){

_servoV.write(_angleV++);

delay(_servoLoopDelay);

}

}

elseif ((_averageBottom-_averageTop)>_i2cVals[IDX_V_SENSITIVITY] && (_angleV-_i2cVals[IDX_V_STEP])>_i2cVals[IDX_V_ANGLE_MIN]) {

// en descendant

Serial.println("moveServos descendant");

delay(_slowingDelay);

pour (int i=0; i < _i2cVals[IDX_V_STEP]; i++){

_servoV.write(_angleV--);

delay(_servoLoopDelay);

}

}

autre {

Serial.println("moveServos ne fait rien");

delay(_slowingDelay);

}

}

//---------------------------------DORMIR

voidasleepFor(unsignedint huitSecondSegments){

Serial.println("endormiPour");

for (unsignedint sleepCounter = huitSecondSegments; sleepCounter > 0; sleepCounter--)

{

LowPower.powerDown(SLEEP_8S, ADC_OFF, BOD_OFF);

}

}

voir rawtilt_pan_tracker_0.3.ino hébergé avec ❤ par GitHub

Étape 4: Assemblage du boîtier du circuit

1. Assurez-vous que l'Ardiuno Pro Mini est inséré dans les en-têtes du PCB.
2. Insérez la base du boîtier du contrôleur SOLAR TRACKER dans les parois du boîtier du contrôleur SOLAR TRACKER et fixez-la avec 2 vis autotaraudeuses à tête fraisée en acier inoxydable 4G x 6 mm.
3. Insérez Ardiuno Pro Mini + PCB avec en-tête 6P dans le vide de la base du boîtier du contrôleur SOLAR TRACKER.
4. Insérez le couvercle du boîtier du contrôleur SOLAR TRACKER dans les parois du boîtier du contrôleur SOLAR TRACKER et fixez-le avec 2 vis autotaraudeuses à tête fraisée en acier inoxydable 4G x 6 mm.
5. Fixez l'assemblage au-dessus à la base du cadre du panneau avec 4 vis autotaraudeuses à tête fraisée en acier inoxydable 4G x 6 mm.

Étape 5: connexion des câbles de montage au contrôleur

Les connexions pertinentes prêtes à partir du précédent Instructable, sont 4 connexions LDR 2P et 2 connexions 3P des servos. Ce qui est temporaire jusqu'à ce que la recharge soit prête, c'est la batterie. Utilisez pour le moment un LiPo 3,7 V qui se termine par une connexion DuPont 2P.

1. Insérez les connexions LDR (pas de polarité) par le haut:

   1. En haut à droite
   2. En haut à gauche
   3. En bas à droite
   4. En bas à gauche

2. Insérez les connexions Servo (avec le fil de signal vers la gauche) par le haut:

   1. Horizontal
   2. Verticale
3. ATTENDEZ D'ÊTRE PRÊT POUR LE TEST PUIS: Insérez le câble d'alimentation 3,7 V CC + ve vers le haut, - ve vers le bas.

Étape 6: Test du contrôleur

Comme indiqué précédemment, le logiciel n'a pas été optimisé pour le flux de travail de charge solaire. Il peut cependant être testé et modifié en utilisant des sources de lumière naturelles (soleil) et non naturelles.

Pour tester le suivi dans un environnement contrôlé, il peut être pratique de régler les MINUTES DE SOMMEIL sur une valeur inférieure (voir l'étape suivante).

Étape 7: Configuration via I2C à l'aide de l'entrée de la console

Cela explique la configuration du contrôleur via un deuxième MCU, la saisie des paramètres dans une fenêtre de console.

1. Téléchargez le script suivant sur un BLOC WIFI D1M (ou Wemos D1 Mini).
2. Déconnecter USB du PC

3. CONNEXIONS PIN:-ve (Contrôleur) => GND (D1M)+ve (Contrôleur) => 3V3 (D1M)SCL (Contrôleur) => D1 (D1M)

   SDA (Contrôleur) => D2 (D1M)

4. Tournez le commutateur SPDT sur CONFIG
5. Connecter USB au PC
6. À partir de l'IDE Arduino, démarrez une fenêtre de console avec le bon port COM
7. Assurez-vous que "Newline" et "9600 baud" sont sélectionnés
8. Les commandes sont entrées dans la zone de texte d'envoi suivies de la touche Entrée
9. Les commandes sont au format Caractère octet octet
10. Si le deuxième octet (troisième segment) n'est pas inclus 0 (zéro) est envoyé par le script
11. Soyez prudent lorsque vous utilisez l'entrée série; revoir ce que vous avez entré avant d'appuyer sur la touche "Entrée". Si vous êtes bloqué (par exemple en changeant l'adresse I2C en une valeur que vous avez oubliée), vous devrez à nouveau flasher le firmware du contrôleur.

Les variantes prises en charge dans le premier caractère de la commande sont:

• E (Enable servo tracking) utile pour arrêter le mouvement pendant la configuration. Ceci est entré en utilisant: E 0
• D (Désactiver le suivi des servos) utile pour démarrer le suivi automatique si vous ne redémarrez pas l'appareil. Ceci est entré en utilisant: D 0
• G (Obtenir la valeur de configuration) lit les valeurs de l'EEPROM et de l'IN-MEMORY: Ceci est entré en utilisant: G (l'index est des valeurs d'octet valides 0 - 13 et 15)
• S (Définir la valeur EEPROM) définit les valeurs sur EEPROM qui sont disponibles après les redémarrages. Ceci est entré en utilisant: S (l'index est des valeurs d'octets valides 0 - 13, la valeur est des valeurs d'octets valides et varie selon la propriété)

Le code est le point de vérité pour les index, mais ce qui suit est utilisé comme guide pour les valeurs/commentaires valides:

• I2C ADDRESS 0 - adresse esclave du contrôleur, le maître en a besoin pour communiquer avec le contrôleur (par défaut 10)
• ANGLE VERTICAL MINIMUM 1 - limite inférieure d'angle vertical du servo (10 par défaut, plage de 0 à 180)
• ANGLE VERTICAL MAXIMUM 2 - limite supérieure d'angle vertical du servo (par défaut 170, plage 0 - 180)
• SENSIBILITÉ VERTICAL LDR 3 - Marge de lecture LDR verticale (20 par défaut, plage de 0 à 1024)
• VERTICAL ANGLE STEP 4 - pas d'angle d'asservissement vertical à chaque réglage (par défaut 5, plage 1 - 20)
• ANGLE HORIZONTAL MINIMUM 5 - limite inférieure horizontale du servo d'angle (par défaut 10, plage 0 - 180)
• ANGLE HORIZONTAL MAXIMUM 6 - limite supérieure d'angle horizontal du servo (par défaut 170, plage 0 - 180)
• SENSIBILITÉ HORIZONTALE LDR 7 - Marge de lecture LDR horizontale (20 par défaut, plage de 0 à 1024)
• HORIZONTAL ANGLE STEP 8 - pas d'angle d'asservissement horizontal à chaque réglage (par défaut 5, plage 1 - 20)
• SLEEP MINUTES 9 - la période de sommeil approximative entre le suivi (par défaut 20, plage 1 - 255)
• VERTICAL DAWN ANGLE 10 - FUTURE USE - l'angle vertical auquel revenir lorsque le soleil se couche
• HORIZONTAL DAWN ANGLE 11 - FUTURE USE - l'angle horizontal auquel revenir lorsque le soleil se couche
• DAWN INTENSITY 12 - FUTURE USE - la moyenne minimale de tous les LDR qui déclenche un début de suivi solaire quotidien
• DUSK INTENSITY 13 - FUTURE USE - la moyenne minimale de tous les LDR qui déclenche la fin du suivi solaire quotidien
• MARQUEUR DE FIN DE VALEURS EEPROM 14 - VALEUR NON UTILISÉE
• INTENSITÉ COURANTE 15 - le pourcentage moyen actuel de l'intensité lumineuse
• MARQUEUR DE FIN DE VALEURS EN MÉMOIRE 16 - VALEUR NON UTILISÉE.

Capture l'entrée série (entrée au clavier dans la fenêtre de la console) et la transmet à un esclave I2C au format char, byte, byte

#comprendre

#defineI2C_MSG_IN_SIZE2

#defineI2C_MSG_OUT_SIZE3

#defineI2C_SLAVE_ADDRESS10

booléen _newData = false;

octet const _numChars = 32;

char _receivedChars[_numChars]; // un tableau pour stocker les données reçues

void setup() {

Serial.begin(9600);

Fil.commence(D2, D1);

retard (5000);

}

boucle vide() {

recvWithEndMarker();

parseEnvoyerCommandes();

}

voidrecvWithEndMarker() {

octet statique ndx = 0;

char endMarker = '\n';

char rc;

while (Serial.available() >0 && _newData == false) {

rc = Serial.read();

if (rc != endMarker) {

_receivedChars[ndx] = rc;

ndx++;

if (ndx >= _numChars) {

ndx = _numChars - 1;

}

} autre {

_receivedChars[ndx] = '\0'; // termine la chaîne

ndx = 0;

_newData = vrai;

}

}

}

voidparseEnvoyerCommandes() {

if (_newData == vrai) {

constchar delim[2] = "";

caractère *jeton;

jeton = strtok(_receivedChars, delim);

char cmd = _receivedChars[0];

indice d'octet = 0;

valeur d'octet = 0;

entier je = 0;

while(jeton != NULL) {

//Série.println(jeton);

je++;

commutateur (i){

cas 1:

jeton = strtok(NULL, delim);

index = atoi(jeton);

Pause;

cas 2:

jeton = strtok(NULL, delim);

if (jeton != NULL){

valeur = atoi(jeton);

}

Pause;

défaut:

jeton = NULL;

}

}

sendCmd(cmd, index, valeur);

_newData = false;

}

}

voidsendCmd(char cmd, index d'octet, valeur d'octet) {

Serial.println("-----");

Serial.println("Envoi de la commande:");

Serial.println("\t" + String(cmd) + "" + String(index) + "" + String(value));

Serial.println("-----");

Wire.beginTransmission(I2C_SLAVE_ADDRESS); // transmettre à l'appareil

Wire.write(cmd); // envoie un caractère

Wire.write(index); // envoie un octet

Wire.write(valeur); // envoie un octet

Wire.endTransmission();

réponse d'octet = 0;

bool hadResponse = false;

si (cmd == 'G'){

Wire.requestFrom(I2C_SLAVE_ADDRESS, 1);

while(Wire.available()) // l'esclave peut envoyer moins que demandé

{

hadResponse = vrai;

réponse = Wire.read();

}

if (hadResponse == true){

Serial.println("Obtention de la réponse:");

Serial.println(réponse);

}autre{

Serial.println("Pas de réponse, vérifiez l'adresse/la connexion");

}

}

}

voir rawd1m_serial_input_i2c_char_byte_byte_v0.1.ino hébergé avec ❤ par GitHub

Étape 8: Étapes suivantes

Revenez régulièrement pour vérifier les modifications apportées au logiciel/matériel.

Modifiez le logiciel/matériel selon vos besoins.

Commentez les demandes/optimisations.