Discussion :

[sparow1]

Bonjour,
Je débute en électronique, j'ai plusieurs petits projet à réaliser.
Et ici je n'arrive pas à simplifier mon chenillard, si quelqu'un sait m'aider, ma boucle ne fonctionne pas comme en C classique j'ai l'impression.
Cordialement.

Code sur MikroC

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
#include <stdio.h>
// Prototypes
void LED1() ; // Sous-programme LED1
 
//*********************************************
 
void main() {
 TRISA = 0b00000010; //port A en sortie sauf RA1
 PORTA = 0b11001000 ; //mettre les sorties à zéro sauf RA6, RA7,RA3
 TRISB = 0b00000001; //port B en sortie sauf RB_0
 PORTB = 0 ; //mettre les sorties à zéro
 pcon.OSCF = 1; //configure le bit 3 du registre pcon pour 4 Mhz
 CMCON = 0b00000111; //désactiver les comparateurs sur RA0
 while(1)  //boucle infinie
 {
  if (RB0_bit==0) { //si RB0 = 0 exécuter la ligne suivante
   LED1(void) ; //Sous-programme LED1
 } //fin du SI
}
}
 
//*********************************************
void LED1(){
 int tabLED[8]={RA0_bit,RB1_bit,RB2_bit,RB3_bit,RB4_bit,RB5_bit,RB6_bit,RB7_bit};
 int i=0;
 for (i = 0 ; i < 8 ; i++)
 {
  tabLED[i] = 1 ;
  delay_ms(250);
  tabLED[i] = 0 ;
 }
}
/*
//sous-programme
void LED1(){ // Début du Sous-programme LED1, on allume et éteind les leds de D4 à D11 l'une après l'autre
 RA0_bit = 1 ;    //sortie RA0 à 1
 delay_ms(250);   //delai d'1/4 sec
 RA0_bit = 0 ;    //sortie RA0 à 0
 RB1_bit = 1 ;
 delay_ms(250);
 RB1_bit = 0 ;
 RB2_bit = 1 ;
 delay_ms(250);
 RB2_bit = 0 ;
 RB3_bit = 1 ;
 delay_ms(250);
 RB3_bit = 0 ;
 RB4_bit = 1 ;
 delay_ms(250);
 RB4_bit = 0 ;
 RB5_bit = 1 ;
 delay_ms(250);
 RB5_bit = 0 ;
 RB6_bit = 1 ;
 delay_ms(250);
 RB6_bit = 0 ;
 RB7_bit = 1 ;
 delay_ms(250);
 RB7_bit = 0 ;
} // Fin du sous-programme LED1 */

Schéma Proteus

[Delias]

Bonjour

Le problème c'est que que le tableau stock les valeurs et non les adresses des E/S
A la ligne 24, c'est les valeurs en cours des pins qui vont être stockées, puis dans la boucle for c'est les valeurs du tableau qui sont modifiées et c'est tout.

Il faut passer par des pointeurs. Sur le principe, il faut stocker les pointeurs vers RXn_bit en ligne 24 et déréférencer le tableau lors de l'affectation dans la boucle for.
Sauf que la norme C ne prévoit pas le travail sur des bits de base cette opération n'est pas possible. Ne travaillant pas sur PIC, je ne sais pas comment cela est spécifiquement implémenté dans le compilateur de cette architecture. (RA0_bit = 1 ; n'est pas conforme à la norme, car c'est une affectation sur un registre d'un seul bit, spécialité de l'embarqué chaque compilateur le traite à sa sauce.)

A voir si un spécialiste des PIC passe par ici.

Bonne suite

Delias

[sparow1]

Je comprends ce que tu veux dire, mais je ne vois pas comment le résoudre :/

[Vincent PETIT]

Salut,
int tabLED[8]={RA0_bit,RB1_bit,RB2_bit,RB3_bit,RB4_bit,RB5_bit,RB6_bit,RB7_bit}; devrait être un tableau d'adresse ou de pointeur. Là tel que que tu le fais dans ta boucle, tu écrases simplement tous les éléments de ton tableau par des 1 et de 0 alors que ce que tu veux c'est affecter 1 ou 0 à une liste de pointeurs qui se trouve dans le tableau.

Tu peux nous dire ce qu'est RA0_bit ? Comment il est définit dans le compilateur ?

[sparow1]

Voici mon schéma

[Delias]

Bonsoir

J'ai cherché un peu plus, et comme je le pensais RA0_bit est un alias vers PORTA.bits.0 selon une autre notation usuelle. CàD un bit d'un registre de 8 bits (dont certains sont éventuellement non existant si le port n'a pas 8 pins). C'est déclaré comme une structure d'entier à taille de 1 bit dont l'adresse est la même que le PORTx.

Et donc il n'est pas possible de manier les RXn_bit directement avec des pointeurs.
Il faut stocker deux éléments: les pointeurs vers les registres de 8 bits (&PORTA et &PORTB) et les masques (bit 0 c'est 1<<0 = 1; bit 1 c'est 1<<1 = 2; bit 2 c'est 1<<2 = 4; etc.) puis utiliser des opérations avec masquage du type PORTA |= masque; // mise à 1 et PORTA &= ~masque; // mise à 0. Sans garantie, il faut que la lecture de PORTA donne bien la valeur écrite dans PORTA avant.

Source: define pointer variable to a bit in PORTx | Microchip

Bonne suite

Delias

[sparow1]

Bonjour,

Je débute en électronique, merci d'employer les termes basiques je n'ai que peu de notions sur le sujet.
J'ai plusieurs petits projets à réaliser.

Pour commencer, je souhaiterais simplifier mon chenillard, si quelqu'un sait m'aider. J'avais essayé de faire une boucle comme en C classique mais je n'ai pas eu le même résultat.
Le schéma m'est imposé.

Cordialement.

Code sur MikroC

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#include <stdio.h>
// Prototypes
void LED1() ; // Sous-programme LED1
 
//*********************************************
 
void main() {
 TRISA = 0b00000010; //port A en sortie sauf RA1
 PORTA = 0b11001000 ; //mettre les sorties à zéro sauf RA6, RA7,RA3
 TRISB = 0b00000001; //port B en sortie sauf RB_0
 PORTB = 0 ; //mettre les sorties à zéro
 pcon.OSCF = 1; //configure le bit 3 du registre pcon pour 4 Mhz
 CMCON = 0b00000111; //désactiver les comparateurs sur RA0
 while(1)  //boucle infinie
 {
  if (RB0_bit==0) { //si RB0 = 0 exécuter la ligne suivante
   LED1(void) ; //Sous-programme LED1
 } //fin du SI
}
}
 
//*********************************************
 
//sous-programme
void LED1(){ // Début du Sous-programme LED1, on allume et éteind les leds de D4 à D11 l'une après l'autre
 RA0_bit = 1 ;    //sortie RA0 à 1
 delay_ms(250);   //delai d'1/4 sec
 RA0_bit = 0 ;    //sortie RA0 à 0
 RB1_bit = 1 ;
 delay_ms(250);
 RB1_bit = 0 ;
 RB2_bit = 1 ;
 delay_ms(250);
 RB2_bit = 0 ;
 RB3_bit = 1 ;
 delay_ms(250);
 RB3_bit = 0 ;
 RB4_bit = 1 ;
 delay_ms(250);
 RB4_bit = 0 ;
 RB5_bit = 1 ;
 delay_ms(250);
 RB5_bit = 0 ;
 RB6_bit = 1 ;
 delay_ms(250);
 RB6_bit = 0 ;
 RB7_bit = 1 ;
 delay_ms(250);
 RB7_bit = 0 ;
} // Fin du sous-programme LED1 */

Schéma Proteus


P.S.: Je me suis permis de remettre ce poste car je ne comprends pas et je préfère redémarrer sur de bonnes bases.

[Vincent PETIT]

Salut !
J'ai fusionné les discussions afin que tout le monde puisse voir ce qui a déjà été dit et pas compris, ça arrive et il n'y a pas de problème.

Je repasse ce soir pour expliquer différemment (très différemment)

A+

[Vincent PETIT]

Bon reprenons depuis le début.
Un chenillard c'est une donnée qui se balade en avançant.

En langage C pour faire avancer une donnée, dans une variable on fait appel à l'opérateur de décalage.

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
unsigned char ma_variable_8bits = 1; // ma_variable_8bits vaut 1 soit 0b00000001
 
ma_variable_8bits = ma_variable_8bits << 1; // ma_variable_8bits vaut 2 soit 0b00000010
ma_variable_8bits = ma_variable_8bits << 1; // ma_variable_8bits vaut 4 soit 0b00000100

Si tu fais une boucle tu peux faire balader le 1 binaire de droite à gauche jusqu'à ce qu'il disparaisse. Maintenant on va aller un peu plus loin avec le même principe mais en l'améliorant. Voici ce que je te demande de t'imaginer ; une variable sur 16 bits ma_variable_16bits, les 8 bits de poids faibles serviront à charger une donnée ma_variable_8bits. Une fois que c'est fait on lance une boucle de décalage 8 fois dans un premier temps.



Je vais devoir te faire participer sinon c'est sur et certain que tu ne comprendras pas ce que je vais faire même si tu vois probablement tout ce qui va se passer.

Je te demande de faire juste un petit programme qui crée une variable 16bits qui s'appellera ma_variable_16bits et que tu charges dans l'octet de poids faible ma_variable_8bits. La variable ma_variable_8bits contiendra au préalable 0b10101010. Une fois chargé, tu fais un décalage à gauche de 1 de ma_variable_16bits mais 8 fois.

Après le chargement de ma_variable_8bits (qui vaut 0b10101010) dans l'octet de poids faible de ma_variable_16bits, tu peux te représenter les choses comme ça :



Pour le seconde partie, voici un exemple de ce que ça donnerait lorsque dans une boucle tu feras des décalages à gauche (ici dans l'image ci dessous, 7 décalages à gauche)



A toi de faire le programme mais pour 8 décalages.

[sparow1]

C'est bien ça ?

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
unsigned char ma_variable_8bits = 0b10101010; // ma_variable_8bits vaut 0b10101010
unsigned char ma_variable_16bits = 0; // ma_variable_16bits vaut 0b00000000 00000000
 
ma_variable_16bits = ma_variable_8bits; // ma_variable_16bits vaut 0b00000000 10101010
for(int i=1;i<8;i++){
    ma_variable_16bits = ma_variable_16bits << 1;
}
// ma_variable_16bits vaudra  0b10101010 00000000

[Vincent PETIT]

C'est bien ça ?

Oui, avec juste deux petites erreurs car ta boucle ne décale que de 7 fois. Tu vas de 1 à 7 int i=1;i<8;i++ en démarrant i à 0 c'est bon int i=0;i<8;i++ et avec mikroC pour déclarer une variable sur 16 bits on la déclarera dans notre cas à nous, en unsigned int https://download.mikroe.com/document...etic_types.htm

Ça donne ceci :

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
unsigned char ma_variable_8bits = 0b10101010;
unsigned int ma_variable_16bits = 0;
 
ma_variable_16bits = ma_variable_8bits;
 
for(int i = 0; i < 8; i++)
{
    ma_variable_16bits = ma_variable_16bits << 1;
}

Allons un peu plus loin, en bouclant tout ça, histoire que le chenillard tourne tout le temps (en vrai je vais me limiter à 3 fois pour ne pas faire une boucle infinie) en faisant tourner la même donnée qui est dans ma_variable_8bits. En gros ça va donner ça.




J'ai juste ajouté une boucle for au dessus de la tienne et ajouté une ligne de code à la fin.

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
	unsigned char ma_variable_8bits = 0b10101010;
	unsigned int ma_variable_16bits = 0;
 
	ma_variable_16bits = ma_variable_8bits;
 
 	for (int j = 0; j < 3; j++)
 	{
		for (int i = 0; i < 8; i++)
		{			
			ma_variable_16bits = ma_variable_16bits << 1;	
		}
 
		ma_variable_16bits = ma_variable_16bits + ma_variable_8bits;
	}

Ici, il est très important que tu comprennes bien cette ligne ma_variable_16bits = ma_variable_16bits + ma_variable_8bits; qui est très différente de ma_variable_16bits = ma_variable_8bits;.

ma_variable_16bits = ma_variable_8bits; signifie, j'écrase tout ce qu'il y a dans ma_variable_16bits (donc je mets son contenue à 0) et j'affecte ma_variable_8bit dedans. Peut importe si ma_variable_8bit occupe que la moitié de ma_variable_16bit ça va tout écraser.

ma_variable_16bits = ma_variable_16bits + ma_variable_8bits; ne fait pas la même chose. Ici on dira ; je prends ma_variable_16bits, je mets dedans son propre contenu (donc on ne remets pas son contenu à 0) et j'ajoute ma_variable_8bit.


Avant de passer à la dernière étape, celle qui te bloque ou comment affecter mes broches RB1_bit, RB2_bit, ... à l'octet de poid fort de ma_variable_16bits, il faut vraiment que tu aies compris tout ce que je viens d'écrire depuis ton message où tu dis ne pas avoir compris. Dans l'étape d'après on va devoir faire des masques binaire du genre RB7_bit doit prendre la valeur du bit numéro 14 de ma_variable_16bits. Il faut vraiment que tout soit clair. Tu peux aussi programmer sur un PC pour faire des essais, moi c'est ce que je fais pour dégrossir, au lieu d'allumer des LED j'affiche des printf que je décode en binaire.