Show Posts
Pages: [1] 2 3 ... 6
1  International / Français / Re: Arduino + Ethernet : réception GET aléatoire on: August 13, 2014, 02:24:27 pm
Tu te connectes à un serveur, tu lui parles puis tu coupes la communication tout de suite, après avoir essayé de lire 1 octet, que tu n'as d'ailleurs probablement même pas reçu: normal que le serveur laisse tomber, il n'a pas commencé à te répondre que tu raccroches…
Quand on parle à quelqu'un, le dialogue se passe beaucoup mieux si on écoute les réponses smiley-grin

Tu devrais remplacer

Code:
    char c = client.read();
        client.stop();

par quelque que chose comme ça:

Code:
while (client.connected())
{
  if (client.available())
    char c = client.read();
}
    client.stop();

en gros, tant qu'on est connecté au serveur, s'il y a un octet à lire, on le lit.

ps: le delay(1000) que tu as ajouté laisse au serveur 1 seconde de temps de réaction, dans ton réseau local ça passe apparement, mais le jour où le réseau est surchargé ou que tu passes par une autre connexion… boum, et tu ne comprendra pas pourquoi ça ne marche plus, puisque "chez moi, y'a tout qui marche, le réseau ici est pourri et cassé, bouhhhh"  smiley
2  International / Français / Re: [3/4 Résolu] Mega 2560 + shield Ethernet serveur accessible sans mot de passe on: August 07, 2014, 01:31:43 am
Bonjour,

ce qui est indispensable, c'est de déclarer la carte Arduino comme maître du bus SPI:

Code:
  pinMode (53, OUTPUT);  // pour Arduino Mega / Mega2560

Mettre les pins chip select en sortie à l'état haut, en fait ça va dépendre des libs que tu utilises.

Si une lib fait un accès au bus SPI dans son begin, après avoir réglé sa pin chip select, les autres périphériques SPI, pour lesquels la pin chip select n'aurait pas encore été mise en sortie à l'état haut, risque de répondre car il peut se croire concerné par la requête SPI qui ne lui est pas destinée.

C'est pourquoi personellement je commence à mettre en sortie à l'état haut tous les chip select de tous les périphériques SPI branchés, avant d'appeler les begin des libs.
3  International / Français / Re: [3/4 Résolu] Mega 2560 + shield Ethernet serveur accessible sans mot de passe on: August 06, 2014, 10:07:44 am
déclarer la carte Arduino comme maître du bus SPI:

Code:
  pinMode (53, OUTPUT);  // pour Arduino Mega / Mega2560

si carte présente dans le lecteur SD, mettre chip select carte SD à HIGH :

Code:
  pinMode (4, OUTPUT);   // select micro SD
   digitalWrite (4, HIGH);

4  International / Français / Re: stockage SD (SPI) + HorlogeDs3234(SPI) on: July 24, 2014, 11:21:16 am
SPI.setMode () ne concerne que la bibliothèque ds3234.
Avant ou après le digitalWrite de la pin chip select n'a pas d'importance.
5  International / Français / Re: stockage SD (SPI) + HorlogeDs3234(SPI) on: July 24, 2014, 05:25:00 am
C'est bien le problème: la lib met le datamode à 1, ce qui pose problème pour les autres modules SPI.

On avait suggéré de mettre le mode à 1 avant les appels au bus SPI et remette à
0 après, dans chaque fonction de la lib qui fait appel à SPI.transfer ()
6  International / Français / Re: stockage SD (SPI) + HorlogeDs3234(SPI) on: July 24, 2014, 03:27:09 am
J'ai essayé,
J'ai mis toutes les modules SPI, en output,  HIGH, comme ça on prends seulement après le controle de chaque module, mais ça n'a pas fonctionné ..



Tu as vérifié ça ?
Quote
vérifie que dans la lib de l'horloge ils ont bien mis SPI.setMode (SPI_MODE1) avant les appels au bus SPI et SPI.setMode (SPI_MODE0) après.

Sinon aoute avant chaque appel appel à une fonction de ta lib DS3234 un appel à SPI.setMode (SPI_MODE1) , et un appel à SPI.setMode (SPI_MODE0) après.

Tu devrais je pense tu faire une série de petits programmes simples, juste pour tester chaque module SPI. Sans les autres modules branchés. Ensuite faire marcher ces programmes de test avec les autres modules branchés, pour confirmer que ton code est correct.
Après seulement regarde ce que tu fais de différent au niveau SPI entre tes programmes de test et ton programme principal.
7  International / Français / Re: Aduino Mega 2560 + shield Ethernet serveur accessible sans mot de passe. on: July 23, 2014, 01:48:58 pm
Pour renvoyer une page sans mot de passe, il suffit de faire comme avant, c'est à dire d'omettre dans l'entête de la page la ligne

WWW-Authenticate: Basic realm=\"something\"

8  International / Français / Re: Aduino Mega 2560 + shield Ethernet serveur accessible sans mot de passe. on: July 22, 2014, 05:28:32 am
Du coup à quel moment les lib "ouvrent" et "ferment" les pins?
Au moment des .begin et .close?
Le problème que j'ai c'est que j'utilise la carte SD pour stocker une partie du code html et le css.
Donc je dois utiliser la carte SD au milieu du code Ethernet.
Donc comment prendre en considération ces éléments au niveau du code, sans utiliser le schéma que j'avais mis en place?

Les libs "ouvrent" les pins chipSelect juste avant de faire un SPI.transfer() et "ferment" juste après.
Donc dans ton code tu ne fais... rien. Tu peux enchaîner les appels au libs ethernet et SD sans problème.

Le seul point critique est l'initialisatation correcte du bus SPI comme indiqué plus haut.
9  International / Français / Re: Aduino Mega 2560 + shield Ethernet serveur accessible sans mot de passe. on: July 22, 2014, 03:13:46 am

Code:
...
  digitalWrite(SS_SD_CARD, LOW);  // SD Card ACTIVE
...
  digitalWrite(SS_SD_CARD, HIGH); // SD Card not active
...
 digitalWrite(SS_ETHERNET, LOW);  // Ethernet ACTIVE
...
  digitalWrite(SS_ETHERNET, HIGH); // Ethernet not active
}

Est complètement inutile alors?

Tout à fait ! Ça fait double emploi avec ce que font les librairies.
10  International / Français / Re: Aduino Mega 2560 + shield Ethernet serveur accessible sans mot de passe. on: July 21, 2014, 05:10:31 pm
@johnlen_fr:

La pin 53 est le chip select du microcontrôleur Atmega sur les cartes Mega1280 et 2560, alors que sur une carte Uno il s'agit de la
Pin 10.
Il faut la mettre en output pour indiquer que le mc est maître du bus SPI et en input pour indiquer qu'il est un esclave.
Sur la Uno la pin 10 est aussi utilisée pour le chip select du module ethernet.

Mettre une pin chip select à low ne désactive pas un périphérique SPI, ça lui dit juste que se qui se passe sur le bus ne lui est pas destiné. C'est la lib qui passe la pin à low avant de parler à un périphérique et le remet à high après.

Mais je mets toujours tous les chip select en output high avant de faire quoi que ce soit sur le bus SPI pour éviter les conflits.

@geryko:

Désole, pour IE je ne sais pas, je n'utilise que des macs...
11  International / Français / Re: Aduino Mega 2560 + shield Ethernet serveur accessible sans mot de passe. on: July 21, 2014, 01:00:58 pm
J'ai voulu tester le code de cbrandt  smiley-wink
Je ne sais pas pourquoi il ne fonctionne pas.
Normalement tu rentres l'adresse IP et le navigateur sort un popup de connexion non?
Mais là rien...
Je reteste ce soir
Tu as mis le code tel quel, en ne changeant que l'adresse ip ?
Ce n'est pas normal que le serial monitor indique une adresse différente à chaque reset smiley-eek
Et l'ip qu'il indique change de quelle façon ?

Edit:
Il me vient à l'esprit que l'initialisation du bus spi dans l'exemple webserver qui m'a servi de base n'est pas très correcte...
Ajoute ceci au début du setup:

Code:
pinMode (53, OUTPUT);
pinMode (10, OUTPUT);
digitalWrite (10, HIGH);
pinMode (4, OUTPUT);
digitalWrite (4, HIGH);
SPI.begin ();

Et retire les périphériques spi autre que le Shields ethernet .
12  International / Français / Re: Aduino Mega 2560 + shield Ethernet serveur accessible sans mot de passe. on: July 21, 2014, 02:26:32 am
Bonjour,

Regarde dans le moniteur série arduino: les lignes de l'entête doivent y apparaître, et cheche celle qui ressemble à
Code:
Authorization: Basic.....

tu verras comment IE envoie cette ligne, peut-être les majuscules ou autre différence....

D'ailleurs, si tu veux autre chose que test / test, c'est là que tu verras la valeur calculée par le navigateur et tu pourras adapter le code arduino en conséquence.

13  International / Français / Re: Aduino Mega 2560 + shield Ethernet serveur accessible sans mot de passe. on: July 20, 2014, 04:08:28 am
Bonjour,

Je pense que le plus simple est d'utiliser ce que le protocle HTTP a mis à notre dispostion: l'entête "WWW-Authenticate".

Il suffit de renvoyer dans l'entête de la page un ligne comme
Code:
WWW-Authenticate: Basic realm=\"something\"
pour indiquer au navigateur web qu'il faut demander un mot de passe à l'utilisateur.

Le navigateur web renvoie dans ce cas la saisie de l'utilisateur dans l'entête de sa requête.
Après il ne reste qu'à analyser ledit entête et repérer la ligne qui va bien:
Code:
Authorization: Basic dGVzdDp0ZXN0
Si la ligne est absente ou différente, renvoyer le code 401 dans la page web. Sinon renvoyer la page désirée.

Bien sûr le code ici dépend de l'utilisateur/mot de passe saisi. Dans notre exemple il faut saisir 'test' pour l'utilisateur et 'test' pour le mot de passe.

Avec cette méthode, le navigateur web gère la saise du mot de passe et peut le mémoriser si l'utilisateur le demande, et le mot de passe ne circule pas trop en clair sur le réseau. Cerise sur le gateau, presque rien à ajouter côté code Arduino !

Code complet, adapté de l'exemple WebServer de l'IDE Arduino:
Code:
/*
  Web Server
 
 A simple web server that shows the value of the analog input pins.
 using an Arduino Wiznet Ethernet shield.
 
 Circuit:
 * Ethernet shield attached to pins 10, 11, 12, 13
 * Analog inputs attached to pins A0 through A5 (optional)
 
 created 18 Dec 2009
 by David A. Mellis
 modified 9 Apr 2012
 by Tom Igoe
 modified 20 july 2014
 by C. Brandt
 */

#include <SPI.h>
#include <Ethernet.h>

// Enter a MAC address and IP address for your controller below.
// The IP address will be dependent on your local network:
byte mac[] = {
  0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ip(192,168,1,2);

// Initialize the Ethernet server library
// with the IP address and port you want to use
// (port 80 is default for HTTP):
EthernetServer server(80);

void setup() {
  // Open serial communications and wait for port to open:
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for Leonardo only
  }


  // start the Ethernet connection and the server:
  Ethernet.begin(mac, ip);
  server.begin();
  Serial.print("server is at ");
  Serial.println(Ethernet.localIP());
}


void loop() {
  //---- quelques variables locales
  char headerLine[80];
  char headerIndex;
  bool passwordOk;


  // listen for incoming clients
  EthernetClient client = server.available();
  if (client) {

    Serial.println("new client");
    // an http request ends with a blank line

    //---- initialisation variables
    passwordOk = false;
    headerIndex = 0;

    boolean currentLineIsBlank = true;
    while (client.connected()) {
      if (client.available()) {
        char c = client.read();

        // if you've gotten to the end of the line (received a newline
        // character) and the line is blank, the http request has ended,
        // so you can send a reply
        if (c == '\n' && currentLineIsBlank) {

          if (passwordOk)
          {
            //---- envoi page web normale ----
            client.println("HTTP/1.1 200 OK");
            client.println ("WWW-Authenticate: Basic realm=\"something\"");
            client.println("Content-Type: text/html");
            client.println("Connection: close");
client.println("Refresh: 5");  // refresh the page automatically every 5 sec
            client.println();
            client.println("<!DOCTYPE HTML>");
            client.println("<html>");
            // output the value of each analog input pin
            for (int analogChannel = 0; analogChannel < 6; analogChannel++) {
              int sensorReading = analogRead(analogChannel);
              client.print("analog input ");
              client.print(analogChannel);
              client.print(" is ");
              client.print(sensorReading);
              client.println("<br />");       
            }
            client.println("</html>");
          }
          else
          {
            //---- envoi code d'erreur 401 ----
            client.println("HTTP/1.1 401 OK");
            client.println ("WWW-Authenticate: Basic realm=\"something\"");
            client.println("Content-Type: text/html");
            client.println("Connection: close");
            client.println();
            client.println("<!DOCTYPE HTML>");
            client.println("<html>");
            client.println("mot de passe incorrect");
            client.println("</html>");
          }
          break;
        }
        if (c == '\n') {

          //---- test ligne d'entete avec mot de passe
          headerLine[headerIndex] = 0;
          headerIndex = 0;
          Serial.println (headerLine);
          if (strcmp (headerLine, "Authorization: Basic dGVzdDp0ZXN0") == 0)
            passwordOk = true;

          // you're starting a new line
          currentLineIsBlank = true;
        }
        else if (c != '\r') {

          //---- mémorisation ligne d'entete courante
          if (headerIndex < 79)
            headerLine[headerIndex++] = c;

          // you've gotten a character on the current line
          currentLineIsBlank = false;
        }
      }
    }
    // give the web browser time to receive the data
    delay(1);
    // close the connection:
    client.stop();
    Serial.println("client disonnected");
  }
}
14  International / Français / Re: stockage SD (SPI) + HorlogeDs3234(SPI) on: July 17, 2014, 04:51:42 am
vérifie que dans la lib de l'horloge ils ont bien mis SPI.setMode (SPI_MODE1) avant les appels au bus SPI et SPI.setMode (SPI_MODE0) après.

extrait de ma lib RTC, dans la méthode de lecture de l'heure:

Code:
SPI.setDataMode (SPI_MODE1);
digitalWrite (_csPin, LOW);

SPI.transfer (0x00); // start addr
for (i = 0; i < 7; i++)
{
n = SPI.transfer (0x00); // get next value

// decode from BCD
b = ((n & 0xF0) >> 4);
a = n & 0x0F;
timeDate2[i] =  10 * b + a;
}

digitalWrite (_csPin, HIGH);
SPI.setDataMode (SPI_MODE0);
15  International / Français / Re: stockage SD (SPI) + HorlogeDs3234(SPI) on: July 17, 2014, 02:24:04 am
Les #include ne viennent pas dans le setup, mais avant.

le mien:
Code:
void setup (void)
{
// external memory ----------------------

#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
xmem::begin (true);
#endif

// SPI cs pins ----------------------

pinMode (53, OUTPUT); // spi master
pinMode (4, OUTPUT); // SDCard cs
digitalWrite (4, HIGH);
pinMode (10, OUTPUT); // Ethernet cs
digitalWrite (10, HIGH);
pinMode (49, OUTPUT); // RTC cs
digitalWrite (49, HIGH);

// Serial ports ----------------------

Serial.begin (115200);
pinMode (1, INPUT_PULLUP); // RX0 - call to 'pinMode' should be moved to HardwareSerial.cpp
Console.begin (&Serial); // for debugging messages

Serial2.begin (9600, 7E1);
pinMode (19, INPUT_PULLUP); // RX1 - call to 'pinMode' should be moved to HardwareSerial.cpp
UCSR1C = 0x24; // 7E1 - should be added as param to Serial.begin ()
Terminal.begin (&Serial2); // interactive shell

// welcome message ----------------------

dprintf ("\n");
dprintf ("\n");
dprintf ("\n");
dprintf ("--------------------------------------------------------------------------------\n");
dprintf ("Home Automation v0.9\n");
dprintf ("%s\n", __TIMESTAMP__);
dprintf ("--------------------------------------------------------------------------------\n");

// 'builtin' devices: (ie. inside box, not necessarily on aduino pcb)
// - atmega2560 (provides i2c, spi, uart, di, do, ai, po)
// - ethernet (needs spi, provides tcp)
// - sdcard (needs spi, provides sd)
// - rtc (needs spi, provides time)

// core libs ----------------------

SPI.begin ();
Wire.begin ();

// RTC ----------------------

pinMode (53, OUTPUT);    // power for rtc
digitalWrite (53, HIGH); // power for rtc
RTC.begin (49);

// ethernet ----------------------

Ethernet.begin (_mac, _ipD, _dnsD, _routerD, _maskD);
dprintf ("eth done\n");

// sdcard ----------------------

SD.begin (4);
dprintf ("sd done\n");

// built-in hardware and services ----------------------

Leds.begin ();
Log.begin ();
HTTP.begin (80);

// set up configuration ----------------------

pinMode (_safemodePin, INPUT_PULLUP);
if (digitalRead (_safemodePin) == LOW)
{
dprintf ("[AUTOMATION] safemode ON - ignoring config file\n");
Automation.begin (false);
Leds.blink (_heartbeatPin, 2);
}
else
{
dprintf ("[AUTOMATION] safemode OFF - ground pin %d at startup to activate\n", _safemodePin);
Automation.begin (true);
Leds.blink (_heartbeatPin, 1);
}
}

le CS de ma carte est la pin 53 (j'utilsie une mega)
à noter que les libs que j'utilise sont d'autres que les tiennes mais le principe est le même:

mettre tous les chips elecr en OUTPUT HIGH avant d'appeler n'importe quelle lib qui fait apper au SPI.
Et ne pas oublier SPI.begin avant l'appel aux libs.

Pages: [1] 2 3 ... 6