Seriele communicatie met Seriele monitor oppakken na onderbreking?

Hoi Mensen,

Ik vraag me af...
Is het mogelijk om de Arduino weer een verbinding te laten starten met de seriele monitor wanneer de verbinding even is onderbroken?
Doel is dat ik van een standalone Arduino (werkend op een eigen voeding) de gelogde data op zijn aangesloten EEPROM wil uitlezen.
Als ik mijn laptop aangesloten houdt, is dat geen probleem, maar wanneer ik deze loskoppel van de Arduino, zal deze de verbinding niet vanzelf weer opstarten.

Nu hoeft het overigens niet per sé een seriele monitor verbinding te zijn hoor.
Ik vind het ook best dat de data elders wordt gespuugd. Als ik het maar terug kan vinden.
Of zijn er andere methodes die "herkennen" dat de laptop weer is aangesloten, waarna hij de data gaat uitsturen?
(OK dit is een retorische vraag, want dit kan gewoon. Ik kan me niet voorstellen dat dat niet kan. Ik weet alleen niet hoe. :wink:)

Ik had al ergens wat gelezen over een statement wanneer er géén seriele verbinding is != .

Hoi.

Je kunt je Arduino gewoon programmeren dat er altijd data naar de seriele poort word gegooid en dat degene die het wil hebben het kan oppakken, dat is geen enkel probleem.
Maar de Arduino heeft een 3e draadje aangesloten naast de RX en de TX pin, namelijk DTR.
Die DTR pin word gebruikt om een pulsje te zetten op de !reset pin van je Arduino, waardoor deze dus gereset word en de bootloader zich eerst even meldt, alvorens jouw sketch aan het woord te laten.
Maar dat laatste wil je waarschijnlijk helemaal niet.

2 oplossingen:

  1. Verbind met je Arduino via pinnen 0 en 1 en niet via de USB poort.

  2. Schakel de reset functie op je Arduino board uit.

De eerste oplossing is vooral een goede wanneer je met andere 5 volt hardware wil verbinden met je Arduino's serial signalen.

De 2e oplossing vergt een kleine wijziging van je board.
De originele boards hebben 2 soldeer eilandjes die met een dun spoortje verbonden zijn.
Wanneer je dat spoortje doorsnijdt, is deze functie uitgeschakeld.
Leg je vervolgens een dikke druppel tin op die eilandjes, verbind je ze weer en schakel je de functie ook weer in.
Onderstaand plaatje verduidelijkt het:

Ik weet niet heel zeker of dit het antwoord is wat je wilde, want ik begrijp de vraag niet 100 %

Als je juist wel wil dat je Arduino gereset word (waarna je dan voor de loop je EEPROM data al gaat dumpen), dan moet je je sketch dus zodanig construeren, en hoef je niets anders te wijzigen.

Bedankt voor je uitleg.
Inderdaad ben ik niet volledig geweest. (moest even snel een vraag op het forum zetten, voor mijn avondritueel begon :slight_smile: )

Ik heb een Arduino Pro Micro.
Deze zit in een standalone apparaat wat enige tijd data verzamelt.
Na die tijd wil ik die data uit kunnen lezen.

Ik test dat nu door in de sketch een stukje in te bouwen waarbij de data na het normale afwikkelen van het verzamelen van data, deze via de USB poort naar mijn seriele monitor spuwd.
Dat deel werkt dus ook. Maar wanneer ik de laptop heb losgekoppeld (terwijl de ProMicro nog steeds bezig is met zijn programma, draaiende op een externe voeding) kan ik de laptop niet meer aansluiten en appelig naar de seriele montor kijken. Die verbinding pakt hij niet meer automatisch op.

Volgens mij moet het kunnen dat ik het zo programmeer dat met een druk op de knop het apparaat in een andere modus komt en steeds die betreffende data gaat uitspuwen, elke paar seconden, zodat ik deze kan oppikken.
Maar dat oppikken is het probleem.
Kom ik dan in programma's als TeraTerm oid? Die seriele data(?) kan uitlezen via de USB poort?

Wat ik tot noch toe deed, was via de gebruikelijke weg een andere sketch laden, terwijl de laptop aangesloten zit en de seriele monitor blijft lopen.
(die uitleessketch trekt de data uit de externe EEPROM en geeft die weer in de SM)
Dit is wat omslachtig en het lijkt me dat dit gemakkelijker kan.

FTMZ

Juist wat dit betreft is een Pro Micro fundamenteel anders, want die heeft de USB ondersteuning op de chip.

Ik heb zelf ook Pro Micro's (ik heb een hoop spul verzameld om ooit eens mee te gaan spelen, maar ja tijd he..), maar ben er nog niet aan toe gekomen daar eens echt mee aan de slag te gaan.

Nu lijkt het mij dat het mogelijk moet zijn om met je Pro Micro te zien dat er een USB verbinding is of niet, en aan de hand daarvan iets te gaan doen.
Zoals luisteren of er data word opgevraagd, of zondermeer data te gaan gooien naar die poort.
Maar daarbij moet je wel opletten.
Een Windows systeem kan bijvoorbeeld incorrecte conclusies trekken wanneer er spontaan data binnen komt op de USB poort (namelijk dat dat dan wel een muis zal zijn en die zich dan dus toe eigenen waardoor je met die poort niet meer kunt verbinden met andere apparatuur).
Je Arduino zal dan geïdentificeerd worden als een Microsoft Serial Ballpoint Mouse in de device manager, een apparaat dat niemand meer zal hebben en destijds na de aanschaf van Windows XP met een hele grote boog en samen met Windows 98 de deur uit geslingerd heeft.

Maar goed, ik heb helaas geen bagage die zou kunnen helpen met dit probleem en kan ook niet zomaar iets vinden dat bewijst dat je Pro Mini naar een al dan niet aangesloten PC kan kijken.

Ik zie nog een vraag voorbij komen over de andere kant; hoe ga je dit binnen halen op je PC.
Wanneer je je favoriete zoekmachine vraagt naar "serial datalogger", vind je wat voorbeelden en reviews van mogelijke kandidaten.
Ik zie bij die resultaten ook mogelijkheden voor het loggen van data via poorten die al in gebruik zijn door andere applicaties, maar heb geen idee hoe (goed) dat werkt.

Wanneer dat voldoende is, kun je ook altijd de EEPROM inhoud naar je PC slingeren tijdens het opstarten van je code.
Daarvoor bouw je een aparte functie die dit afhandelt, en roep je die functie aan vanuit setup.
Dat moet natuurlijk wel nadat je verder alles wat je daarvoor nodig hebt, ook hebt geïnitialiseerd.
In dit geval moet je dus de Arduino resetten om de data te ontvangen via de seriële poort.

Ik zal me er eens in gaan verdiepen.
Het apparaat is natuurlijk ook een seriele verbindingsweg.
Moet goed komen.

Als ik de oplossing vind, post ik hem hier.

Hallo,

Ik heb zelf geen pro micro maar je kan overwegen (op basis van wat ik gelezen heb) om de tweede seriële poort op de micro the gebruiken samen met een usb naar serieel omzetter.
Op die manier ben je los gekoppeld van de problematiek van de on board usb poort en heb je een poort die zal doen wat je wil dat ze doet.

Mvg,
John.

Een van de terminal programmas die automatisch weer verbinden is Tera Term; ik hoop dat je Windows gebruikt.

Een paar dingen om rekening mee te houden

1)
if(!Serial) en while(!Serial) vertellen je slechts eenmalig dat een verbinding met een terminal programma was gemaakt. Je kunt het niet gebruiken om te bepalen of een ProMicro wordt los getrokken van de PC's USB poort of als het terminal programma wordt gesloten, alleen om te bepalen of de verbinding ooit was opgezet.

Onderstaande sketch demonstreert dat.

#define PROMICRO

#ifdef PROMICRO
const byte ledPin = 17;
#define LED_ON LOW
#else
const byte ledPin = LED_BUILTIN;
#define LED_ON HIGH
#endif

void setup()
{
  digitalWrite(ledPin, !LED_ON);
  pinMode(ledPin, OUTPUT);

  Serial.begin(57600);

  // just to make sure we can see that the led is initially off
  delay(5000);
}

void loop()
{
  static uint32_t nextUpdateTime;
  uint32_t currentTime = millis();

  // if terminal not open
  if (!Serial)
  {
    digitalWrite(ledPin, LED_ON);
  }
  else
  {
    digitalWrite(ledPin, !LED_ON);
  }
}

Run het programma zonder terminal programma; de led zal aangaan om aan te geven dat er geen verbinding met een terminal programma is. Vervolgens kun je een terminal programma starten, vebinden met de seriele poort en de led zal uit gaan. Als je de verbinding in het terminal programma sluit (of het terminal programma sluit) zal de led niet opnieuw aangaan.

Noot: while(!Serial) gebruik je om er zeker van te zijn dat je geen data van de Arduino mist na een reboot. De code wacht to een terminal programma de verbinding heeft opgezet; het is iets dat je waarschijnlijk niet wilt gebruiken als je onmiddelijk na een reset data wilt verzamelen van b.v. sensors.

2)
Bij een 32U4 (en waarschijnlijk iedere processor met native USB) kun je de timing van je programma grondig verknoeien als je print, vevolgens de verbinding verbreekt en blijft printen. Onderstaand programma demonstreert dat

#define PROMICRO

#ifdef PROMICRO
const byte ledPin = 17;
#define LED_ON LOW
#else
const byte ledPin = LED_BUILTIN;
#define LED_ON HIGH
#endif

byte ledState = !LED_ON;

void setup()
{
  digitalWrite(ledPin, ledState);
  pinMode(ledPin, OUTPUT);

  Serial.begin(57600);
}

void loop()
{
  static uint32_t nextUpdateTime;
  uint32_t currentTime = millis();

  // blink led
  ledState = !ledState;
  digitalWrite(ledPin, ledState);
  delay(200);

  // print some data every second
  if (currentTime >= nextUpdateTime)
  {
    nextUpdateTime += 1000;
    Serial.println(currentTime / 1000UL);
  }
}

Dit programma flitst de led (200ms) en print iedere seconde. Na het laden van het programma zal de led keurig blinken zoals verwacht. Als je vervolgens een vebinding opzet in het terminal programma zal het allemaal netjes blijven werken en zul je data in het terminal programma zien. Als je echter de verbinding verbreekt zal de led onregelmatig gaan flitsen. Als je de 1 seconde timing verwijdert zal de led ongeveer idere seconde flitsen inplaats van ieder 200ms.

Om dit te voorkomen moet je controleren of er ruimte is in de zend buffer om nog te printen. Dit doe je met Serial.availableForWrite() zoals hieronder getoond. Het getal 10 is min of meer willekeurig gekozen; als b.v. de langste data slechts 5 is kun je het veranderen naar 5. Ik denk dat de maximale waarde 64 is, maar weet dat niet zeker; de buffer is 64 bytes maar er is misschien nog een verborgen buffer waar de data nog naar toe wordt gecopieerd.

#define PROMICRO

#ifdef PROMICRO
const byte ledPin = 17;
#define LED_ON LOW
#else
const byte ledPin = LED_BUILTIN;
#define LED_ON HIGH
#endif

byte ledState = !LED_ON;

void setup()
{
  digitalWrite(ledPin, ledState);
  pinMode(ledPin, OUTPUT);

  Serial.begin(57600);
}

void loop()
{
  static uint32_t nextUpdateTime;
  uint32_t currentTime = millis();

  // blink led
  ledState = !ledState;
  digitalWrite(ledPin, ledState);
  delay(200);

  // print some data every second
  if (currentTime >= nextUpdateTime)
  {
    nextUpdateTime += 1000;

    // print some data every second
    if (Serial.availableForWrite() > 10)
    {
      Serial.println(currentTime / 1000UL);
    }
  }
}

Hoi sterretje.

De tip voor de 32U4 was mij nog niet bekend.
Dus dank je wel voor de beschrijving van het mogelijke probleem inclusief de oplossing daarvoor.
Karma ++

Graag gedaan, MAS3. En nu die ProMicro afstoffen en gaan gebruiken :smiley:

Bovenstaande is een korte samenvatting van Serial.print on Leonardo very slow after disconnection from serial; ik heb het deze keer geverifieerd op een ProMicro.

Die laatste aangeboden oplossingen gaan me way boven the pet.
Ivm de ruimte in het device, moet ik alles klein en compact houden.
Inmiddels had iemand mij ook getipt voor een data terminal programma (Cool term).
Die detecteert de data op de lijn en print die net als de serial monitor doet, op mijn scherm.
Dat kan ik opslaan of kopiëren.
Dit bevalt me best. Alleen moet ik de serial monitor uit hebben staan. In de situaties dat ik het gebruik, zal die toch uit staan, dus is dat geen probleem.

This topic was automatically closed 120 days after the last reply. New replies are no longer allowed.