Bonjour,

Il n'est pas possible d'interrompre un delay() par contre il est possible de faire un systéme comme celui de l'exemple "BlinkWithoutDelay" :
http://www.arduino.cc/en/Tutorial/BlinkWithoutDelay

De cette manière on peut continuer à faire quelque chose pendant qu'une autre action est en attente.

Bonjour,

En lisant le schéma disponible via le lien que tu nous a donnez (http://www.nuelectronics.com/download/projects/LCDshield_v1_1.pdf) il semblerait que cette shield utilise les broches digital 4, 5, 6, 7, 8, 9 et A0 donc pas de probléme de compatibilité avec la partie ethernet de l'ethernet shield.

Cependant pour la partie carte SD de l'ethernet shield il faudra re-cabler la broche digital 4 de l'ethernet shield vers la broche digital 3 sinon les deux shields vont être en conflit (un simple fil sur la broche D4 "en l'air" vers D3 fera très bien l'affaire).

Pour déclarer l'objet "liquidcrystal" avec cette configuration de broche :

Code:

LiquidCrystal lcd(8, 9, 4, 5, 6, 7);

Et si tu souhaite utiliser la carte SD il faudra un

Code:

SD.begin(3);

Avec c'est deux petites modifications tu pourra utiliser les exemples de arduino.cc sans probléme

Re, ben y'avait pas grand chose, mais c'est bizarre parce que ça ne correspond pas aux valeurs de mon code ^^

Code:

if (direction++ == 8) direction = 0;

VS

Code:

if (direction++ == 7) direction = 0;

Je suis vraiment trop bête !! c'était pas variable++ mais ++variable !!

Voila le code corrigé :

Code:

/*
 * La sélection de la couleur se fait par un boutons LED, et deux autres boutons de naviguer de LED en LED
 * Le potentiomètre joue sur le delais de multiplexage d'affichage des LED
 */

/* Pin Definition */
#define LATCH_PIN 8     //595 pin 12
#define CLOCK_PIN 12    //595 pin 11
#define DATA_PIN  11    //595 pin 14

//595 pin 16 connected to 5VDC
//595 pin 8 connected to GND
#define BPG   4
#define BPLED 3
#define BPD   2

byte tLedA[4] = {
  0,17,33,49};

byte tLedB[4] = {
  0,18,34,50};

byte tLedC[4] = {
  0,20,36,52};

byte tLedD[4] = {
  0,24,40,56};

byte tLedE[4] = {
  0,65,129,193};

byte tLedF[4] = {
  0,66,130,194};

byte tLedG[4] = {
  0,68,132,196};

byte tLedH[4] = {
  0,72,136,200};

unsigned int ledDelay;
byte lastBpG = 0, lastBpD = 0, lastBpLed = 0, direction = 0, ledA = 0, ledB = 0, ledC = 0, ledD = 0, ledE = 0, ledF = 0, ledG = 0, ledH = 0;

void setup() {
  Serial.begin(9600);

  pinMode(LATCH_PIN, OUTPUT);
  pinMode(DATA_PIN, OUTPUT);
  pinMode(CLOCK_PIN, OUTPUT);

  pinMode(BPG, INPUT);
  digitalWrite(BPG, HIGH) ;

  pinMode(BPD, INPUT);
  digitalWrite(BPD, HIGH) ;

  pinMode(BPLED, INPUT);
  digitalWrite(BPLED, HIGH) ;
}

void loop() {

  byte etatBpLed = digitalRead(BPLED);
  byte etatBpD = digitalRead(BPD);
  byte etatBpG = digitalRead(BPG);

  if (etatBpG != lastBpG && etatBpG)
    if (--direction == -1) direction = 7;

  if (etatBpD != lastBpD && etatBpD)
    if (++direction == 8) direction = 0;

  if (etatBpLed != lastBpLed && etatBpLed)
    switch (direction){
    case 0:
      if (++ledA == 4) ledA = 0;
      break;
    case 1:
      if (++ledB == 4) ledB = 0;
      break;
    case 2:
      if (++ledC == 4) ledC = 0;
      break;
    case 3:
      if (++ledD == 4) ledD = 0;
      break;
    case 4:
      if (++ledE == 4) ledE = 0;
      break;
    case 5:
      if (++ledF == 4) ledF = 0;
      break;
    case 6:
      if (++ledG == 4) ledG = 0;
      break;
    case 7:
      if (++ledH == 4) ledH = 0;
      break;
    }

  byte tLed[4] = {
    tLedA[ledA] | tLedE[ledE], tLedB[ledB] | tLedF[ledF], tLedC[ledC] | tLedG[ledG], tLedD[ledD] | tLedH[ledH]   };

  for (byte i = 0; i < 4; i++){
    digitalWrite(LATCH_PIN, HIGH);
    digitalWrite(LATCH_PIN, LOW);
    shiftOut(DATA_PIN, CLOCK_PIN, MSBFIRST, tLed[i]);     
    digitalWrite(LATCH_PIN, HIGH);

    delay(4);
  }

  lastBpLed = etatBpLed;
  lastBpG = etatBpG;
  lastBpD = etatBpD;
}

Et bien sur l'explication qui va avec :
Prenons int i = 5;
Si l'on fait Serial.println(i, DEC); il s'affiche 5, normal.
maintenant avec Serial.println(i++, DEC); il s'affiche toujours 5 car la valeur de i est passé à la fonction avant d'étre incrémenté.
Avec Serial.println(++i, DEC); i est incrémenté puis passé à la fonction, ici il s'afficherait 6.

Heureuse de base ...pour le coup je suis vraiment désolé, faire une si grosse boulette

Juste donc le CS correspond au CE sur l'exemple du lien avec la libraire Mirf ?

Oui c'est une des nombreuses appellations pour la broche permettant de dire au périphérique SPI qu'on va lui envoyer quelque chose.
"Chip Select" (CS), "Chip Enable" (CE), "Slave Select" (SS) ou "Slave Enable" (SE) veulent dire la même chose, c'est juste une question d'appellation.

Bonjour,

Le câblage du nRF24L01 avec une mega est le suivant :
nRF24L01 -> Arduino
VCC -> 3v3 (ou 5v sur les breakouts de sparkfun)
GND -> GND
MISO -> MISO sur D50
MOSI -> résistance de 10K -> MOSI sur D51
SCK -> résistance de 10K -> SCK sur D52
CS -> résistance de 10K -> Dx (broche au choix)
CSN -> résistance de 10K -> SS sur D53 (avec la librairie cité plus bas il est possible de choisir une autre broche)
IRQ -> Dx (broche au choix, optionnel)

Les résistances de 10K sont juste là pour protéger le nRF24L01 du 5v.
CS permet de choisir si l'on souhaite émettre ou recevoir.
CSN correspond au "Chip Select" du bus SPI.
IRQ permet via une interruption de savoir si il y a de l'activité (active à l'état bas, attachInterrupt(0, xx, FALLING) pour l'utiliser) il n'est pas obligatoire de la câbler.

Personnellement j'utilise cette librairie : http://www.arduino.cc/playground/InterfacingWithHardware/Nrf24L01
Elle est relativement simple d'utilisation et très puissante.

Y'avais que un soucis de  comptage de +1 pour les changements couleur et LED, en gros c'est comme si il y avait eu 9 LED et 5 couleur avec ton code, donc vraiment pas grand chose, j'ai remis les bonnes valeurs et ça marche nikel...

Tu peut poster ton code modifié juste que je puisse voir ou j'avais fait l'erreur ?
On apprend de ses erreurs, au moins celle là je la ferait plus ^^

Désolé, et merci

Bin pour le coup c'est moi qui est foiré donc c'est plutôt à moi de m'excuser ^^

D'accord, mais donc l'adresse et le port du proxy je les mets où ?

Quand tu veux te connecter à google par exemple tu crée un objet "Client" comme ça :

Code:

byte ipGoogle = {74, 125, 39, 103}; // Ip de google.fr
Client google(ipGoogle, 80);

void demandePage()
{
google.println("GET /search?q=azerty HTTP/1.0");
google.println("Host: www.google.com");
google.println();
google.println();
// Faire ici le nécessaire pour la lecture de la réponse
}

Maintenant si tu veux utiliser ton proxy tu change l'ip par celle du proxy

Code:

byte ipProxy = {192, 168, 1, 10}; // Ip de ton proxy
Client proxy(ipProxy, 8080); // Beaucoup de proxy tourne sur le port 8080

void demandePage()
{
proxy.println("GET http://www.google.com/search?q=azerty HTTP/1.0");
proxy.println("Host: www.google.com");
proxy.println("Cache-control: no-cache");
proxy.println();
proxy.println();
// Faire ici le nécessaire pour la lecture de la réponse
}

Bonjour,

Avec avr-size tu peut connaitre la taille de ton programme en flash et les données statique en ram, mais pas les données dynamique (variable temporaire d'une boucle, d'une fonction ...).

Pour connaitre le nombre d'octets de ram restant au moment de l'exécution il existe plusieurs méthode décrite ici :
http://www.arduino.cc/playground/Code/AvailableMemory

Pour avoir la taille en ram / flash statique il faut ajouter l'option -C à la commande avr-size, ça donne un aperçu des sections mémoire de manière plutôt "user friendly".

Ok donc en gros je dois mettre l'ip et le port du proxy à la place de celle du serveur, et dans host l'adresse ou l'ip de ma cible ?

La requête en elle même est pas trop changer, juste le GET (ou le POST) qui n'est plus un chemin relatif mais un chemin absolu avec le protocole (http://).

Normalement pour faire une requête HTTP il faut se connecter au serveur directement, avec le chemin absolu il suffit d'envoyer la requête au proxy qui va s'occuper de refaire la requête (avec le chemin relatif cette fois) auprés des serveurs du site "cible".

Bonjour,

Une requête HTTP "normal" ce fait ainsi :

Code:

GET /search?q=azerty HTTP/1.0
Host: www.google.com

en envoyant la requête directement à l'ip de google.com (dans cette exemple).

Avec un proxy c'est pas plus compliqué :

Code:

GET http://www.google.com/search?q=azerty HTTP/1.0
Host: www.google.com
Cache-control: no-cache

mais cette fois si la requête doit être envoyé à l'ip du proxy.

[Edit:]

22 secondes avec le bootloader contre 17 secondes avec le bitbang

J'aurai penser que le bootloader aurait était plus lent ... mais alors ça veut dire que le bootloader "optiboot" de l'arduino UNO (à 115200 bauds) doit être "théoriquement" 3x plus rapide.

Ce qui est sur c'est qu'avec le mkII (une belle bête au passage, qui coute quand même chère (et le mkII ICE j'en parle même pas )) sa devrait prendre grand max 5s.

Edit: je viens de faire le test avec le bootloader de la UNO :

Code:

avrdude.exe: writing flash (21162 bytes):
Writing | ################################################## | 100% 3.80s

avrdude.exe: reading on-chip flash data:
Reading | ################################################## | 100% 3.12s

Seulement 6 secondes pour lire / écrire

Les secrets ont l'air bien gardés !!  l' "Open" est plutôt dans une phase 'closed' ou 'condidentiel'  !!!

IDE 1.0 annonçé imminent depuis 2 semaine..... mais :
mise en ligne discrete d'une version 0.23 le 9/11

ARDUINO 0023 - 2011.11.09
* Added .inf files for R3 boards.
* Updated to optiboot 4.4.
* Included combined firmwares for ATmega16U2.

La vache j'avais même pas vu la version 0023 (bon bin +100Mo à DL c'est parti)  !
Il ont fixé le bug des 29Ko du bootloader sur les cartes UNO ...

Mais pourquoi un IDE 0023 alors que l'IDE 1.0 va arrivé !?
Ne serais-ce pas une astuce pour nous dire qu'il va falloir attendre ?

Pas cool ça ! Même pas une petite annonce via twitter ou le blog rien ... et dev.arduino.cc est complétement fermé depuis le bug du playground ...

Pour utiliser avrdude en ligne de commande il faut installer winAVR :
http://sourceforge.net/projects/winavr/files/WinAVR/20100110/
(bien pensez à cocher "ajouter au PATH" quand il le propose)

Sous windows pour avoir la console : touche Windows et touche R simultanément.
Si l'installation a réussi en entrant la commande avrdude il devrait s'afficher l'aide d'avrdude.

Pour utiliser le bootloader arduino (2009 pas uno) :

Code:

avrdude -p m328p -b 57600 -c arduino -P COM3 -U flash:w:Audio_PCM.hex

!! Pensez à changer COM3 par le port série qui convient et d'utiliser la commande "cd" pour naviguer jusqu'au dossier qui contient le .hex

A pars les initialisations à zero en plus que j'ai rajouté, les deux codes sont syntaxiquement identique, je vois pas ce qui pourrait donner un résultat aléatoire
Enlève les initialisations à zero en plus peut être que ...

Code:

byte lastBpG = 0, lastBpD = 0, lastBpLed = 0, direction, ledA ledB, ledC, ledD, ledE, ledF, ledG, ledH;

Mais bon je pense pas que ce soit ça ...

D'accord d'accord ! Donc je peux m'en servir de plusieurs par exemple pour modifier le contenu du mail et son sujet ? =)

Il suffit de faire :

client_OVH.print( "GET /vers/ta/page.php5" );
client_OVH.print( "?variable=valeurs" ); // le 1er paramètres commence avec ?
client_OVH.print( "&variable=valeurs" ); // les suivants avec &
client_OVH.println( "&variable=valeurs" ); // le derniérs avec & et un retour ligne à la fin

Coté php tu récupère les variables avec $_GET["variable"]