mettre a un plusieurs sorties

Bonsoir, je suis tout nouveau dans le onde arduino et je pense que je vais bien m'amuser car cela parit tres puissant! en revanche je bute déja sur quelques petites choses: j'aurais voulu mettre plusieurs sorties au niveau haut mais pour le moment, je fais digitalWrite(41, HIGH); digitalWrite(48, HIGH); digitalWrite(20, HIGH); digitalWrite(14, HIGH); digitalWrite(15, HIGH); digitalWrite(16, HIGH); etc etc y aurait il un moyen de n'avoir qu'une ou 2 lignes pour ecrire cela?

Dans plusieurs sketch, j'ai vu: digitalWrite(AllColo[colo], LOW); et je n'ai trouvé aucune explication concernant les [] pourriez vous m'expliquer?

merci à vous

Je ne sais pas pour ça mais tu peux faire une tableau, et mettre tout à 1 en une ligne.

j'ai fait une recherche avec tableau et ca ressemble a ce que je veux faire ! je creuse encore un peu!

merci

Salut,

Si tu as plusieurs sorties consécutives, tu peux utiliser une boucle for:

for (int Pin = 14; Pin = 16; Pin++) {
    digitalWrite((Pin), HIGH);
  }

Mais si tu n'as que 3 sorties, ca fait autant de lignes... :grin:

Bonne soirée

Salut, quel Arduino possèdes-tu, un modèle Mega ou l'Arduino Due ? Si tu possède un Arduino Mega, tu peux utiliser les commander AVR pour changer l'état de toutes les sorties d'un même port d'un seul coup avec DDRX et PORTX avec X la lettre du port. Par contre il faudrait que tu changes les Pins que t'utilise pour les mettre sur le même port et l'ajout de ce type de commande pourrait rendre moins flexible les modifications de ton programme.

bonjour c'est un mega 2560 . en fait c'est un cube led 3D 7x7x7 sans circuit de multiplexage (directement 49 sorties sur les leds et 7 sorties pour l'alimentation en negatif des niveaux) et j’essaie de faire de nouveaux effets (style des lettres qui viennent du fond du cube pour arriver devant mais pour le moment je trouve que c'est hyper long, il me faut recopier digitalwrite pour chaque led que je veux allumer puis éteindre en fonction du niveau . J'ai cherché quelque chose de plus simple mais je ne trouve que des cubes avec des registres à décalage. si vous avez des idées, le tableau doit pouvoir m'aider mais comment lui dire que les sorties ne sont pas consécutives ?

merci

si vous avez des idées, le tableau doit pouvoir m'aider

La solution t'as déja été donnée:

tu peux utiliser les commander AVR pour changer l'état de toutes les sorties d'un même port d'un seul coup avec DDRX et PORTX avec X la lettre du port

Mais pour cela il consulter la partie "Port Manipulation" sur le site Arduino et mieux encore te plonger dans la datasheet du micro-controleur .

mais comment lui dire que les sorties ne sont pas consécutives

Ah le beurre et l'argent du beurre ! Tu peux changer ton câblage pour choisir des Entrées/Sorties appartenant à un même port. En cherchant un peu on trouve des tables de correspondance entre les dénominations du fabricant du micro-controleur (Atmel) et celle du fabricant du circuit imprimé (Arduino).

Le câblage est-il déjà complétement réaliser ou c'est encore possible de tout modifier ? Sa serait plus simple en regroupant chaque ligne ou colonne (en fonction de comment le cube est réalisé) sur un même port pour les manipuler par la suite avec les commandes avr de port. Sinon, si le câblage est définitif, on devras faire avec le montage actuel mais sa seras moins simple.

Pighixxx a réalisé un gros travail en regroupant dans un schéma clair le pinout de l'arduino et de l'atmega regroupé :

Les ports sont représentés en jaune clair. Un inconvénient de l'arduino méga est qu'il "éparpille" un peu partout les sorties d'un même port au lieu de les placer à proximité (surement par soucis de routing et de groupage des fonctions).

Bonjour,

Ce que tu cherches à faire s’appelle de la “manipulation de port”, tu peut en avoir un exemple ici :
http://www.arduino.cc/en/Reference/PortManipulation

Le schéma (très bien fait au passage) que t’as donné BananaFanatics te sera tu aides capitale :wink:
C’est lui qui te permettra de faire la correspondance “numéro arduino” → Port / bit AVR.

Tu auras aussi besoin de maitriser le “bitwise”, j’ai fait un tuto simple sur ce sujet :

Sinon tu as une autre solution : déclarer un tableau (constant) avec tes numéros de broches et faire une fonction de ce style :

void superDigitalWrite(const byte broches[], const byte valeurs[], byte nombreDeValeurs) {
  for(byte i = 0; i < nombreDeValeurs; ++i)
    digitalWrite(broches[i], valeurs[i]);
}

Mais cela n’as pas l’avantage (contrairement à la manipulation de port) de fixer les niveaux logiques de chaque broche en une seule fois.

merci à vous tous pour ces informations, je vais lire tout cela mais pour un débutant ça me parait bien compliqué, mais avec du temps!!! et un peu d'aide du forum de temps en temps!!!

skywodd: Tu auras aussi besoin de maitriser le "bitwise", j'ai fait un tuto simple sur ce sujet : http://skyduino.wordpress.com/2013/04/05/tuto-le-bitwise-pour-les-nuls/

Merci skywodd, ce totu est vraiment très bien fait & pédagogique, ça démystifie très bien !

bonsoir,
j’ai trouvé un programme qui va pas mal, ou on lui donne les positions des leds que l’on veut sous la forme d’un tableau. Le problème c’est que si j’allume un grand nombre de led du même niveau, la luminosité diminue . J’ai essayé de mettre un transistor mais cela ne change pas!
En revanche, si j’allume les mêmes led directement, j’ai la bonne luminosité.

merci de votre aide

 prog_uchar PROGMEM PatternTable[] = {
 B1101001, B1101001,  B1101001, B1101001, B1101001, B1101001,  B1101001,
       B0000000, B0000000,  B0000000, B0000000, B0000000, B0000000,  B0000000,
       B0000000, B0000000,  B0000000, B0000000, B0000000, B0000000,  B0000000,
       B0000000, B0000000,  B0000000, B0000000, B0000000, B0000000,  B0000000,
       B0000000, B0000000,  B0000000, B0000000, B0000000, B0000000,  B0000000,
       B0000000, B0000000,  B0000000, B0000000, B0000000, B0000000,  B0000000,
       B0000000, B0000000,  B0000000, B0000000, B0000000, B0000000,  B0000000,B,}
 void loop()        
 // declare variables
byte PatternBuf[PLANESIZE]; // saves current pattern from PatternTable
int PatternIdx;
byte DisplayTime; // time*100ms to display pattern
unsigned long EndTime;
int plane; // loop counter for cube refresh
int patbufidx; // indexes which byte from pattern buffer
int ledrow; // counts LEDs in refresh loop
int ledcol; // counts LEDs in refresh loop
int ledpin; // counts LEDs in refresh loop

// Initialize PatternIdx to beginning of pattern table
PatternIdx = 0;
// loop over entries in pattern table - while DisplayTime>0
do {
// read pattern from PROGMEM and save in array
memcpy_P( PatternBuf, PatternTable+PatternIdx, PLANESIZE );
PatternIdx += PLANESIZE;
// read DisplayTime from PROGMEM and increment index
DisplayTime = pgm_read_byte_near( PatternTable + PatternIdx++ );
// compute EndTime from current time (ms) and DisplayTime
EndTime = millis() + ((unsigned long) DisplayTime) * TIMECONST;

// loop while DisplayTime>0 and current time < EndTime
while ( millis() < EndTime ) {
patbufidx = 0; // reset index counter to beginning of buffer
// loop over planes
for (plane=0; plane<CUBESIZE; plane++) {
// turn previous plane off
if (plane==0) {
digitalWrite( PlanePin[CUBESIZE-1], HIGH );
} else {
digitalWrite( PlanePin[plane-1], HIGH );
}

// load current plane pattern data into ports
ledpin = 0;
for (ledrow=0; ledrow<CUBESIZE; ledrow++) {
for (ledcol=0; ledcol<CUBESIZE; ledcol++) {
digitalWrite( LEDPin[ledpin++], PatternBuf[patbufidx] & (1 << ledcol) );
}
patbufidx++;
}

// turn current plane on
digitalWrite( PlanePin[plane], LOW );
// delay PLANETIME us
delayMicroseconds( PLANETIME );
} // for plane
} // while <EndTime
} while (DisplayTime > 0); // read patterns until time=0 which signals end

je viens de faire un essai avec un 2N2222 et une résistance de base de 1K sur le 1er niveau mais bizarrement, il n'y a plus que le premier niveau qui est allumé! j'ai aussi essayé avec un BC 547 et une resistance de 6k, meme soucis?

a votre avis qu'est ce qui peut clocher?

Schéma du montage ?

je suis trop nul! je sors de mon arduino en 0V alors que pour piloter le 2N2222 il faut du positif! il faut que je modifie mon programme!!! a moins que l'on puisse mettre un PNP pour piloter la masse avec un zero volts sur la base ? mais je ne pense pas!

j'ai réussi à faire un test avec un transistor de récup (en collecteur commun, je ccrois): BC251 B mais il n'a que 100mA d'Ic. Cela fonctionne parfaitement quelle serait une référence pour un PNP qui permettrait de passer un plus fort courant ? 2N2907A ou un tip?