Problème de programmation d'ATtiny

Bonjour,

Je viens voir sur ce forum si je trouve des réponses à mes questions !! :slight_smile:
Car je suis confronté à un problème qui me donne du fil à retordre.

J'utilise un module RF low-cost, qui marche très bien. Le but est de traiter avec mon Attiny85 la chaine binaire qui arrive par une broche de mon AVR.
J'ai donc créé une liste d'entier d'une taille de 256. Je lance une boucle infinie, et je remplis ma liste.
En parallèle de cela, mon idée était de réussir à détecter un verrou disons 1001101010 (stocké dans une liste lui aussi)

Le problème se pose, car mon Attiny ne réagit pas comme il devrait. A savoir, dans mon code lorsque je détecte la première valeur du verrou je met une led à 1 et si il n'y a pas d'erreur elle reste à 1. Sauf qu'il semble que mon Attiny n'aime pas le mélange :

  • boucle infini
  • variables de comptage qui s'inscrémente de 1 à chaque tour dans la boucle
  • la condition if() else basique

Ma question est donc la suivante : Y a t'il des restrictions à l'utilisation de variables dans l'AVR, boucle ou condition qui pourrait faire en sorte que le programme n'alloue pas la mémoire correctement ou provoquerai ce comportement anormal ?

PS : Je n'ai volontairement pas mis mon code, car je programme mon AVR avec un Raspberry!! Mais globalement le code reste très tout à fait lisible. Je ne voulais juste pas surcharger mon premier post.
Néanmoins si rien ne permet de résoudre mon problème comme ça, je posterai mon code pour que vous y voyez plus clair biensur ! :slight_smile:

Il semblerait que le problème vienne du mauvais choix du type de mes chaines. A savoir c'était des chaines de 256 int. Avec des chaines de 256 char ça marche mieux !

Qu'en pensez-vous ?

Comment dire ....

Tu fais les questions et les réponses et tu ne donnes pas d'information sur le code alors on ne peut pas trop juger.

Bonjour déjà,

Je vois pas en quoi donner plus d'information sur un problème intrasèque au fonctionnement d'un attiny te pose problème.
Sinon j'ai volontairement pas donné mon code, car c'est pas tant le programme le problème.. mais une question sur l'allocation de la mémoire

Ma question est relativement simple du coup, suite au message à la réponse que j'ai envoyé.
Pourquoi quand j'initialise deux "int[256]" cela fait planter l'attiny85, alors que "char[256]" non ?

Bonjour,

KZL__:
Ma question est relativement simple du coup, suite au message à la réponse que j'ai envoyé.
Pourquoi quand j'initialise deux "int[256]" cela fait planter l'attiny85, alors que "char[256]" non ?

Bah sans doute parce qu'un AtTiny85 ne possède que 512 octets de SRAM et que 2xint[256] en réclament 1024... :grin:

Ah oui en effet ! Ce n’est pas bête du coup :slight_smile:
Je n’y aurai jamais pensé avec mon petit niveau en programmation d’avr ! Merci bien.

Bien, outre ça j’ai remarqué 2 choses qui m’embete car le composant ne fait pas ce que je voudrai qu’il fasse.
Voici mon code, j’ai essayé de vous mettre l’essentiel

// I/O
#define F_CPU 1000000UL
#include <avr/io.h>

// Améliore la lisibilité du code..
#define SET_MODE(DDB, MODE)  { if (MODE == "INPUT") DDRB &= ~(1 << DDB); else if (MODE == "OUTPUT") DDRB |= (1 << DDB); }
#define WRITE_OUTPUT(PB,VALUE) { if (VALUE == "HIGH") PORTB |= (1<<PB); else if (VALUE == "LOW") PORTB &= ~(1<<PB); }
#define READ_INPUT(PB) PINB & (1 << PB)

// Délai
#define DELAY 1000 // en ms
#include <util/delay.h>

// Alias pour améliorer la lisibilité
// Broche relié au recepteur RF 433MHz
#define BROCHE_RF DDB2
#define RF PB2
// Broche relié à une LED témoin + Input du Raspberry
#define BROCHE_LED DDB3
#define LED DDB3
// Broche de debug relié à une input du Raspberry
#define BROCHE_DEBUG DDB4
#define DEBUG PB4

int main(void) {

	int i, j;
	char bytes[128];

	char tailleVerrou = 22;
	char verrou[32] = {1,0,0,1,0,1,1,0,1,0,0,1,1,0,0,1,0,1,1,0,0,1};

	SET_MODE(BROCHE_RF, "INPUT");
	SET_MODE(BROCHE_LED, "OUTPUT");
	SET_MODE(BROCHE_DEBUG, "OUTPUT");

        i = 0; j = 0;
  	while(1) {

                // On met ce qu'on récupère du récepteur RF dans la chaine "bytes", une série de 0 et 1 
		if(READ_INPUT(RF)) {

			WRITE_OUTPUT(LED, "HIGH");
			bytes[i] = 1;

		} else {

			WRITE_OUTPUT(LED, "LOW");
			bytes[i] = 0;
		}

                // On cherche ici à savoir si le verrou se trouve dans le flux de bytes
		if(bytes[i] == verrou[j]) {

			WRITE_OUTPUT(DEBUG, "HIGH");
			j = (j+1)%256;

		} else if(bytes[i] == verrou[0]) {

			WRITE_OUTPUT(DEBUG, "HIGH");
			j = 1;

		} else {

			WRITE_OUTPUT(DEBUG, "LOW");
			j = 0;
		}

                // Si on a trouvé tous les elements on sort de la boucle !		
		if(j == tailleVerrou-1) {

			break;
		}

		i = (i+1)%256;
	}
	
	WRITE_OUTPUT(DEBUG, "LOW");
	WRITE_OUTPUT(LED, "LOW");
	return 0;
}

En quelques mots, DEBUG et LED correspondent à des sorties de mon AVR, qui envoi des données mon Raspberry, qui les traitent encore dans un programme, me permettant d’avoir une information fiable sur ce qui sort et ce qui rentre dans l’avr, ce qui a été reçu et envoyé, etc…

Question 1 : (Si j’ai une réponse à cette question, pas la peine de répondre à la 2 !!) Est-ce que quelqu’un voit un problème général dans ma façon de déclarer des variables ? Quelque chose que j’aurai pu loupé du faite d’être sur un système très limité en terme de mémoire ? Vu le comportement bizarre de mon composant, je suppose un problème de mémoire ou quelque chose que je ne comprends pas.

Question 2 : Je ne comprends pas pourquoi le programme réagit différemment lorsque j’initialise mes variables i et j des 2 façons suivantes :

int i, j;
i = 0; j = 0;

Dans ce cas, j’obtiens les valeurs suivantes depuis mon programme raspberry :
Emission : 1001011010011001011001101001011010011001011001
Reception : 1001011010010001011001101001011010011001011001
Debug : 1111111111111111111111111111111111011111111111

int i = 0, j = 0;

Dans ce cas :
Emission : 1001011010011001011001101001011010011001011001
Reception : 1001011010011001011111111001011010011001010111
Debug : 1001011010011001011111111001011010011111011111

Les 2 cas posent problèmes, car je m’attendais à avoir un 1 quand le bit emission = reception et 0 sinon

Question 3 : Concernant le code ci-dessous :

if (bytes[i] == verrou[j]) ...

Je remarque que la comparaison ne se fait pas correctement, puisque je sors immédiatement de ma boucle, j’en déduis donc que ma variable “j” a dépassé la valeur 22 très/trop rapidement, mais pourquoi, il n’y a pas de raison ?? ^^" Ou bien que je me suis fait ejecté de la boucle sans y etre rentré comme avant avec le problème d’allocation.

Bonsoir,

J’ai simplifié mon code, car je pense que j’avais un problème de surcharge mémoire. A présent l’AVR réagit correctement.

// I/O
#define F_CPU 1000000UL
#include <avr/io.h>

// Améliore la lisibilité du code..
#define SET_MODE(DDB, MODE)  { if (MODE == "INPUT") DDRB &= ~(1 << DDB); else if (MODE == "OUTPUT") DDRB |= (1 << DDB); }
#define WRITE_OUTPUT(PB,VALUE) { if (VALUE == "HIGH") PORTB |= (1<<PB); else if (VALUE == "LOW") PORTB &= ~(1<<PB); }
#define READ_INPUT(PB) PINB & (1 << PB)

// Délai
#define DELAY 1000 // en ms
#include <util/delay.h>

// Alias pour améliorer la lisibilité
#define BROCHE_RF DDB2
#define RF PB2
#define BROCHE_LED DDB3
#define LED DDB3
#define BROCHE_DEBUG DDB4
#define DEBUG PB4

int main(void) {

	SET_MODE(BROCHE_RF, "INPUT");
	SET_MODE(BROCHE_LED, "OUTPUT");
	SET_MODE(BROCHE_DEBUG, "OUTPUT");

	int i = 0, j = 0;
	char bytes[64];

	const char tailleVerrou = 22;
	const char verrou[22] = {'1','0','0','1','0','1','1','0','1','0','0','1','1','0','0','1','0','1','1','0','0','1'};
	
  	while(1) {

		char bit;
		if(READ_INPUT(RF)) {

			WRITE_OUTPUT(LED, "HIGH");
			bit = '1';

		} else {

			WRITE_OUTPUT(LED, "LOW");
			bit = '0';
		}

		if(j >= tailleVerrou-1) {
			
			break;
			
		} else if(bit == verrou[j]) {

			WRITE_OUTPUT(DEBUG, "HIGH");
			j++;

		} else if(bit == verrou[0]) {

			WRITE_OUTPUT(DEBUG, "HIGH");
			j = 1;

		} else {

			WRITE_OUTPUT(DEBUG, "LOW");
			j = 0;
		}
	}
	
	WRITE_OUTPUT(DEBUG, "LOW");
	WRITE_OUTPUT(LED, "LOW");
	return 0;
}

Néanmoins je n’arrive pas à obtenir les résultats que je souhaite à savoir que sur mon Raspberry je devrai obtenir les résultats suivants (le code en rouge est la clef de verrou #1 que je cherche à détecter) :

  • Chaine émise :
    1001011010011001011001101001011010011001011001

*Signal reçu (possibilité d’erreur dû aux temps morts) :
1001011010011001011001101001011010011001011001 → BROCHE_LED

*Signal de débug (possibilité d’erreur dû aux temps morts) :
111111111111111111111100000000000000000000000 → BROCHE_DEBUG

Alors que actuellement je reçois :

  • Chaine émise :
    1001011010011001011001101001011010011001011001

*Signal reçu (possibilité d’erreur dû aux temps morts) :
1001011010011001011001101001011010011001011001 → BROCHE_LED

*Signal de débug (possibilité d’erreur dû aux temps morts) :
1001011010011001011001101001011010011001011001 → BROCHE_DEBUG

A croire que le signal de debug recopie le signal emis, alors que le code fait tout autre chose
J’espère que l’explication est claire. N’hésitez pas si jamais, il y a qqchose que vous ne comprenez pas.