Bonjour,
Je me permets de vous solliciter car je rencontre des problèmes de manipulations sur les fonctions dites "bitwise".
Je suis dans le cadre d'une démarche professionnelle, ou j'ai pris sur moi de développer une maquette de test pour un de nos produit. Il s'agit, en l'état de réaliser un test complet d'une carte UC (unité centrale) . Pour m'aider dans ma tache je dispose d'instructions de test précises édictées par les ingénieurs ayant développés la carte.
Je suis en cours de développement sur les autres fonctions, mais les fonctions de test concernant les ports du µC me posent problème.
Je débute en programmation (2 mois seulement), mon domaine étant plutôt la conception électronique, et la réparation de ces cartes, je vous demanderais donc un peu d'indulgence...
Ce que je veux faire :
-> Tester les ports du micro contrôleur de la carte
référence du µC -> M68HC11E de NXP
Je prend ici pour exemple le port PORTB, qui est le premier du long annuaire que j'ai a tester, car j'ai besoin de comprendre, et de développer un code pour ce port dans un premier temps pour développer le reste des fonctionnalités de test.
La méthodologie que je veux adopter :
-> Me connecter via une extension de port aux broches externe du bus (comme prévu dans le protocole de test original)
-> Contacter une adresse spécifique (ici : 0x0A140)
-> Lire le PORTB (qui doit être à l'état bas 0)
-> Changer successivement les bit 0->1
-> Confirmer l'écriture en relisant ces bits
-> Remettre le port en état initial - Ecriture 1 -> 0
-> Lire une nouvelle fois le résultat.
L'enchainement de ces étapes doit être validé soit : Par un booleen / Par une boucle if-else / Par un while qui doit dire "Le port est dans le bon état + Le port est dans l'état initial"
pour être "PASS" sinon "FAIL"
La finalité :
Avoir un test automatique et fonctionnel qui permet de detecté toute anomalie sur le bus et notamment sur le µC, pour permettre un diagnostic fiable, et des prises de décisions pour la réparation de ces produits.
Etant dans un cadre de confidentialité sur les produits, je ne peux pas vous révéler 100% des informations, mais concernant le sujet cela ne devrait pas poser de soucis.
Concernant le code, ne prenez pas une crise cardiaque, je suis pas à l'aise avec les "bit"...
//PIN
const int local_p = 4; // PB7 sur u8
const int manqueu_p = 11; // PB6 sur u8
const int defaut_vertP1 = 12; // NE PAS TENIR COMPTE
const int presrad = 5; // PB5 sur u8
const int coupim = 6; // PB4 sur u8
const int anobat = 7; // PB3 sur u8
const int chargbas= 8; // PB2 sur u8
const int charghaut = 9; // PB1 sur u8
const int couprad = 10; // PB0 sur u8
//ADRESSES
uint16_t x = 0b10000000; // Adresse du port cible en HEX 0x0A140
uint16_t PORTG = 0x0A141; // Integration future du prochain port
//BITS
uint16_t bit; // Bit de stockage de chaque element du port pour test
uint16_t bit0;
uint16_t bit1;
uint16_t bit2;
uint16_t bit3;
uint16_t bit4;
uint16_t bit5;
uint16_t bit6;
uint16_t bit7;
// PULSE
unsigned long duration; // Stockage pour fonction print serial de la valeur du pulse HAUT
unsigned long lowduration; // Stockage pour fonction print serial de la valeur du pulse BAS
unsigned long duration1; // Integration future du prochain port
unsigned long lowduration1; // Integration future du prochain port
//BIT STATE
int haut = 1; // ETAT HAUT BIT
int bas = 0; // ETAT BAS BIT
uint16_t verif0; // Variable de verification initiale de la fonction bitRead()
uint16_t state; // Test d'un stockage lu en bitRead() pour lui appliquer des opérandes et inverser l'état (ex : !=, ~, ...)
uint16_t verif; // Variable de verification 1 intermediaire de la fonction bitRead()
uint16_t verif2; // Variable de verification 2 finale de la fonction bitRead()
void setup()
{
pinMode(local_p, OUTPUT);
digitalWrite(local_p, HIGH);
Serial.begin(9600);
Serial.println("--------------------------");
Serial.println("Lecture de l'adresse"); // Je demande à lire l'adresse pour confirmer qu'elle est correcte
Serial.println(x, BIN);
delay (1000);
verif0 = (bitRead(x, bit));
state = (bitRead(x, bit)& local_p ); // Partie brouillon car je veux lire mes bit
Serial.println("Lecture initiale du port : "); // Je demande à lire l'adresse pour confirmer qu'elle est correcte
Serial.println(state, BIN);
bit = (bitWrite(x, 0 , ~state)); //Et remplacer leur valeur par l'inverse = 0->1 et 1-> 0
/* bit = (bitWrite(x, 1 , !state));
bit = (bitWrite(x, 2 , !state));
bit = (bitWrite(x, 3 , !state));
bit = (bitWrite(x, 4 , !state));
bit = (bitWrite(x, 5 , !state));
bit = (bitWrite(x, 6 , !state));
bit = (bitWrite(x, 7 , !state)); */
pinMode(local_p, INPUT);
Serial.println("Verification d'ecriture"); // Je demande à lire le résultat
for (int bit = 0; bit < 7; bit++)
{
verif = bitRead(x, bit);
Serial.print(verif,BIN);
}
Serial.println();
pinMode(local_p, OUTPUT);
// On recommence exactement de la même façon
bit = (bitWrite(x, 0 , state));
/* bit = (bitWrite(x, 1 , !state));
bit = (bitWrite(x, 2 , !state));
bit = (bitWrite(x, 3 , !state));
bit = (bitWrite(x, 4 , !state));
bit = (bitWrite(x, 5 , !state));
bit = (bitWrite(x, 6 , !state));
bit = (bitWrite(x, 7 , !state)); */
pinMode(local_p, INPUT);
Serial.println("Verification d'ecriture"); // Je demande à lire le résultat
for (int bit = 0; bit < 7; bit++)
{
verif2 = bitRead(x, bit);
Serial.print(verif2,BIN);
}
Serial.println();
/////////////////////////////////////// // Je test le pulse du port pour savoir si il est actif (et éviter toute fausse lecture/ecriture)
Serial.println("--------------------------");
Serial.println("Si pulse 0 = Carte inactive");
duration = pulseIn(local_p, HIGH);
Serial.print("duree du pulse HIGH...");
Serial.println(duration);
lowduration = pulseIn(local_p, LOW);
Serial.print("duree du pulse LOW...");
Serial.println(lowduration);
/////////////////////////////////////////////// // Je demande une image du port finale pour vérifier que tout est dans le même état qu'à la base
delay (1000);
Serial.println("#########################");
Serial.println("IMAGE LECTURE PORT FINAL");
Serial.println(bit, BIN);
Serial.println("INITIALE");
Serial.println(0b10000000, BIN);
Serial.println("#########################");
delay (1000);
if ((lowduration = 0) && (duration = 0)) {
Serial.println("TEST FAIL...");
}
else-(x = verif2);{
Serial.println("TEST PASS!");
}
delay (1000);
exit(0);
}
void loop () {}
Ce que j'attendrais de vous :
- Des pistes ou des solutions pour rendre mon code opérationnel (car actuellement même si les câbles sont débranchés tout fonctionne => intérêt 0)
- Des conseils pour m'améliorer sur le domaine de la manipulation de bit
- Une optimisation de mon code en utilisant notamment le mapping arduino (registre DDR(B,C,D...)
- Comprendre comment passer de la théorie des opérandes au code (parce que sur internet y'a pas spécialement de code qui me permette de faire le lien, où j'arrive pas à les comprendre...)
exemple : A ^ (1<<n)
J'espère avoir été complet, dans le cas contraire, n'hésitez pas à me demander des informations supplémentaires.
Ca fait 3 jours que je buche la dessus sans arriver à réellement obtenir un résultat satisfaisant, c'est pour cela que je demande conseil, et je n'ai pas la science infuse, je prendrais donc vos remarques, critiques, conseils avec plaisir!
Merci de votre temps