Utilisation du FTDI en plus du GPRS, conflit ?

Bonjour,

Je crée actuellement un programme pour Arduino UNO + GPRS Shield V2 + USB Host Shield 2.
En simple, je reçoit des données via ma carte usb host que je doit envoyer via TCP sur le réseau GPRS.

J'arrive parfaitement à lancer les deux examples fournis dans les librairies:

Carte GPRS Shield V2:
-Description: GPRS Shield V2.0 | Seeed Studio Wiki
-Example testé (fonctionne): GPRS_Shield_Suli/GPRS_TCPConnection.ino at master · Seeed-Studio/GPRS_Shield_Suli · GitHub

Carte USB Host V2:
-Description: https://www.circuitsathome.com/products-page/arduino-shields/usb-host-shield-2-0-for-arduino
-Example testé (fonctionne correctement): USB_Host_Shield_2.0/USBFTDILoopback.ino at master · felis/USB_Host_Shield_2.0 · GitHub

Mon problème survient quand j'essaye de combiner les deux, le fait de créer un objet de type FTDI fais planter le GPRS (au niveau de la fonction gprs.join(), puis le arduino reboot. Si je commente juste la déclaration de l'objet FTDI, le GPRS remarche...

Voici mon code, qui pour le moment devrait juste se connecter en DHCP puis afficher l'IP (j'ai mis un commentaire au niveau de la ligne qui fais planter le prog):

#include <adk.h>
#include <cdcftdi.h>
#include "pgmstrings.h"
#include <GPRS_Shield_Arduino.h>
#include <SoftwareSerial.h>
#include <Wire.h>
#include <Suli.h>

#define PIN_TX    7
#define PIN_RX    8
//make sure that the baud rate of SIM900 is 9600!
//you can use the AT Command(AT+IPR=9600) to set it through SerialDebug
#define BAUDRATE  9600

class FTDIAsync : 
public FTDIAsyncOper
{
public:
  virtual uint8_t OnInit(FTDI *pftdi);
};

uint8_t FTDIAsync::OnInit(FTDI *pftdi)
{
  uint8_t rcode = 0;

  rcode = pftdi->SetBaudRate(115200);

  if (rcode)
  {
    ErrorMessage<uint8_t>(PSTR("SetBaudRate"), rcode);
    return rcode;
  }
  rcode = pftdi->SetFlowControl(FTDI_SIO_DISABLE_FLOW_CTRL, FTDI_SIO_XON_XOFF_HS);
  if (rcode)
    ErrorMessage<uint8_t>(PSTR("SetFlowControl"), rcode);

  return rcode;
}


char http_cmd[] = "GET /media/uploads/mbed_official/hello.txt HTTP/1.0\r\n\r\n";
char buffer[512];
GPRS gprs(PIN_TX, PIN_RX, BAUDRATE,"m2mdata");
USB Usb;
FTDIAsync        FtdiAsync;
FTDI             Ftdi(&Usb, &FtdiAsync); //ligne qui fait Bugger le prog

uint32_t next_time;
void setup() {
  /* GPRS INITIALIZATION */
  Serial.begin(9600);
  // use DHCP
  Serial.println("DEBUT");
  gprs.init();
    Serial.println("DEBUT2");

  // attempt DHCP
  while(false == gprs.join()) {
      Serial.println("gprs join network error");
      delay(2000);
  }

  // successful DHCP
  Serial.print("IP Address is ");
  Serial.println(gprs.getIPAddress());

  gprs.close();
  gprs.disconnect();
  Serial.println("SETUP:OK");
}

void loop() {

}

Je vous remercie par avance.

Salut,

A mon avis c'est la RAM qui est pleine. Y'a un code ici pour savoir la quantité encore libre : Measuring Memory Usage | Memories of an Arduino | Adafruit Learning System

En effet il semblerait que cela vienne de la ram... Le soucis c'est que comment je peut faire ? Mon programme est déjà bien condensé :confused: Il y a des moyens d'avoir plus de SRAM ?

Encore merci pour ton aide =)

marcarduino:
Il y a des moyens d'avoir plus de SRAM ?

Alléger le code des fonctions qui ne servent pas, ou passer sur Mega.

Ok ok merci pour votre aide =)

Bonne journée.

Un moyen simple c'est d'utiliser F() qui permet de placer des constantes dans la flash.

Serial.println("gprs join network error"); ==> "gprs join network error" est stocké dans la RAM
Serial.println(F("gprs join network error")); ==> "gprs join network error" est stocké dans la flash

Très bien je vais essayer.
J'ai fais quelque tests de consommation RAM sur les différents examples fournis dans la lib des shields afin de savoir combien de SRAM theorique qu'il me faudrait:

Programme GPRS Seul (pour TCP Connection): 416 octets dans la SRAM restants = 1632 octets consommés
USB Host: 1496 octets dans la SRAM restants = 552 octets consommés
SDCard: 1171 octets dans la SRAM restants = 877 octets consommés

Un total de plus de 3ko...

Pensez vous qu'il est possible de jongler entre le FTDI et le GPRS sans que pour autant les deux utilisent de la SRAM ?
Pour faire simple, mon arduino aura besoin de se connecter qu'une seule fois par jour au GPRS pour envoyer un seul fichier stocké dans la carte SD.
Mon objectif serait donc de libérer la RAM du FTDI au moment ou je veux envoyer le fichier puis de libérer la RAM du GPRS pour relancer le FTDI en attendant l'envoi du jour prochain. Es-ce envisageable ?

Comme ça je dirais que c'est pas possible (d'une manière simple en tout cas). Il faut soit passé à un µC plus musclé en RAM, soit optimisé les lib ... A étudier : certaines lib utilise des buffer de RAM en pré-réservant des espaces de RAM. Si c'est le cas et que la lib est bien foutu, il doit y avoir un #define en début de lib pour justement donner la taille de cette espace.

Mais je pose une question : c'est quoi l'utilité du FTDI ?