Hoe krijg ik een getal van de terminal

Deze sketch moet bij het intikken van een letter m of M een getal (bv 123.4) kunnen ontvangen. Dat eerste lukt mij, maar het getal krPreformatted textijg ik niet voor elkaar. dit is de sketch:`#include <Arduino.h>
#include “messages.h”
#include <Streaming.h> /* Streaming | Arduiniana */
#include “String.h”

#define KEY_MOVE_LC 0x60
#define KEY_MOVE_UC 0x40

int incomingByte = 0; // for incoming serial data
int commkey = 0; // for incoming serial data
int x;
char str[1];
boolean recvByte = false;
// Buffer to store incoming commands from serial port
String inData;
String comdata = “”;

void setup() {
Serial.begin(9600);
Serial.println(“Serial conection started, waiting for a command…”);
Serial.print(">");
}// end setup

void loop() {
while (Serial.available() > 0)
{
char recieved = Serial.read();
switch (recieved) {
case ‘m’:
case ‘M’:
Serial.println(“Move to: “);
getServovalue();
break;
default:
Serial.println(“Invalid command”);
break;
}// end switch
if (recieved == KEY_MOVE_LC || recieved == KEY_MOVE_UC) {
Serial.println(“Got move command”);
} else
{
Serial.print(”>”);
}
}// while
}// end loop

void getServovalue() {
String readString;
#define isdigit(X) (((X) >= ‘0’) && ((X) <= ‘9’))
Serial.print("Enter value: ");
while (Serial.available()) {
char c = Serial.read(); //gets one byte from serial buffer
readString += c; //makes the String readString
Serial.println(readString);
delay(2); //slow looping to allow buffer to fill with next character
}// end while
}// end getServovalue()
`

Hoi.

Je sketch is niet goed geplaatst, ik weet niet of dat komt doordat jij iets niet goed hebt gedaan of dat dat door de forum software komt.
Daarom het volgende:
Type 3 keer op de ` toets (onder de Esc) , en dan 2 keer op de enter, zodat je 3 keer een apostrof ziet staan en op de volgende regel terecht komt.
Plak dan je sketch, en ga naar de volgende regel en type dan weer 3 keer de apostrof en 2 keer de enter.
Nu moet de sketch er wel goed in staan (dit geldt voor de nieuwe software, bij de oude werkte dat heel anders).

Dan heb ik je sketch eens vlug over gekeken.
Je vertelt dat het getal (zoals 123.4) binnenhalen niet werkt (je vertelt niet waarom het niet werkt, zie onderaan).
Maar dat doe je ook niet in je sketch.
Ten eerste kijk je bij elke toetsdruk of dat een cijfer toets was.
Dus de punt of de komma ga je dan missen.
Maar je kijkt ook niet verder dan de eerste toets die ingedrukt word.
De seriële verbinding zendt elke teken zo snel mogelijk door.
Er wordt dus niet afgewacht tot je klaar bent en bijvoorbeeld op enter ofzo drukt.
Het commentaar bij serial.read() vertelt dat ook.
Dus moet je ook kijken of er nog meer binnen komt.
Als je altijd met een getal als 123.4 werkt, moet je dus 5 maal een toetsdruk binnen krijgen, en dat mag dan dus ook een punt of een komma zijn.
Dus daar zul je dan ook iets voor moeten bouwen.
Ik zou mezelf opsluiten in getServovalue totdat ik het getal compleet binnen zou hebben.
Ik zou er ook over nadenken of er aan het eind van het getal op zoiets als een enter toets gedrukt moet worden, en zou dan zelfs ook kijken of er tussendoor misschien op een backspace knop gerukt word (deze twee geven weer een extra dimensie aan de programmeer oefening).

Het is handiger als je niet alleen vertelt dat het niet werkt, maar ook waarom jij vind dat het niet werkt.
Dus vertel dan wat je had verwacht te zien, en wat je in plaats daarvan te zien kreeg.
Dan is het voor de mensen die je willen helpen hopelijk duidelijker wat er mis zou kunnen gaan.
Want het antwoord hierboven is gebaseerd op aannames en kan iets heel anders aankaarten dat dat waar jij op vastgelopen bent.

Bedankt voor je uitleg, maar ik ben visueel gehandicapt(mijn blikveld links is maar 10% en rechts 75%) dus niet alle webpagina’s zijn voor mij even duidelijk. Ook de IDE is niet echt goed voor menswen met een visuele beperking… Maar jouw aanbevelingen heb ik geprobeerdt te verwerken. Hierbij een for-loop ingebouwd dat dan 5 bytes zou moeten lezen van de terminal en daar de variable readString moeten maken, maar de sketch komt in het geheel niet in deze loop. Hieronder de aangepaste sketch:```
#include <Arduino.h>
#include “messages.h”
#include <Streaming.h> /* Streaming | Arduiniana */
#include “String.h”

#define KEY_MOVE_LC 0x60
#define KEY_MOVE_UC 0x40

//int incomingByte = 0; // for incoming serial data
//int commkey = 0; // for incoming serial data
boolean recvByte = false;

String inData;
String comdata = “”;

void setup() {
Serial.begin(9600);
Serial.println(“Serial conection started, waiting for a command…”);
Serial.print(">");
}// end setup

void loop() {
while (Serial.available() > 0)
{
char recieved = Serial.read();
switch (recieved) {
case ‘m’:
case ‘M’:
Serial.println(“Move to: “);
getServovalue();
break;
default:
Serial.println(“Invalid command”);
break;
}// end switch
if (recieved == KEY_MOVE_LC || recieved == KEY_MOVE_UC) {
Serial.println(“Got move command”);
} else
{
Serial.print(”>”);
}
}// while
}// end loop

void getServovalue() {
String readString;
#define isdigit(X) (((X) >= ‘0’) && ((X) <= ‘9’))
Serial.print("Enter value: ");
while (Serial.available()) {
for(int idx = 1; idx < 6; idx++) { // Get 4 numbers pls decimal-point
char c = Serial.read(); //gets one byte from serial buffer
if (isdigit(c)) { // Is it a digit (0-9)
readString += c; //makes the String readString
Serial.println(readString);
delay(2); //slow looping to allow buffer to fill with next character
}// end if digit
}// end for-loop
}// end while
}// end getServovalue()


hopelijk weet jij een oplossing

Hoi.

Ik nam je niets kwalijk hoor, maar omdat men van software (en platform) veranderd is, is er veel dat nu anders werkt.
Je code plaatsen is ook nog niet helemaal goed gegaan, omdat je schijnbaar die drie apostrofs ook op een eigen regel moet plaatsen.

Je vertelt dat je niet bij het binnenhalen van de cijfers uitkomt.
Dus daar gaan we eerst aandacht aan besteden.

Je kunt weten dat je in getServovalue terecht bent gekomen doordat je dan de betreffende vraag (Enter value: ) in de serial monitor gaat krijgen.
Dus das een mooi stukje debugging dat in je sketch als vaste feature is ingebouwd.

Krijg je die vraag dus niet, dan heb je dus schijnbaar niet aan de daarbij behorende voorwaarde voldaan.
Die voorwaarde is dat je eerst de m intoetst, en dan de M intoetst, zo lijkt het.
Maar dat ga je nooit zien want je kunt niet tegelijk een m en een M intoetsen, terwijl je er wel maar 1 keer op controleert.
Das dus een stukje in je code wat niet goed gaat.
Kopieer daarom eens het stukje dat uitgevoerd moet worden dat bij de hoofdletter M staat, eens naar boven bij de m zonder hoofdletter.
Dat is dus dit stukje:

        Serial.println(“Move to: “);
        getServovalue();
        break;

Wanneer het dan wel werkt, is het goed.
Maar je kunt ook kijken of het een hoofdletter is of niet, en er dan een niet hoofdletter van maken of andersom (net wat je liever hebt).
Dat kun je op dezelfde wijze doen als je nu al doet voor de getallen, met deze 2 methoden:

isLowerCase()
isUpperCase() 

Maar voor nu is dat nog niet nodig.

Ik zie dat je nu zes waardes gaat binnenhalen, van 1 tot en met 6.
Over het algemeen tellen we liever vanaf nul, dus dan zouden vijf karakters (123.4) tellen tussen nul en vier maar das verder nog niet heel belangrijk.
Dat betekent dus dat het later wel handiger zal kunnen blijken, dus wellicht een idee om er alvast aan te gaan wennen.

Je controleert ook of het een cijfer is wat is ingetoetst, maar je controleert niet of er een ander toegestaan teken bij komt, zoals de komma of de punt.
Wanneer het laatste karakter een enter toets mag zijn, dan heb je dat waarschijnlijk niet nodig in de rest van je sketch en ik zou er daarom geen ruimte voor reserveren.
Maar wanneer je dat wel zou willen gebruiken, moet je er natuurlijk wel op controleren.

      if (isdigit(c)|| c == '.'|| c == ',') { // Is it a digit (0-9), dot or comma

Wanneer je de komma of de punt toestaat, maar alleen een punt wil gebruiken, kun je uiteraard van een eventueel ingetoetste komma een punt maken.

** LET OP **
Code gekopieerd uit dit forum werkt mogelijk niet goed, omdat het forum onzichtbare tekens toevoegt.
Tijdens het testen (verify) kreeg ik een enorm aantal foutmeldingen door zulke tekens.

Type de code daarom handmatig over (sorry, buiten mijn invloedssfeer).

Ik gebruik dus niet de ingebouwde seriele monitor maar een terminalprogramma. ik krijg dan deze output:
Serial conection started, waiting for a command…

Move to:
Enter value: >
*k kom dus wel in de routine. En dan gaat het mis.
edit
Ik heb een paar testoutputs ingebouwd zijnde $ en
in de aan te roepen routine:

  String readString;
#define isdigit(X) (((X) >= '0') && ((X) <= '9'))
  Serial.println("Enter value(0-180 at.5 interval");
  Serial.print("$");
  while (Serial.available()) {
    for (int idx = 1; idx < 6; idx++) { // Get 4 numbers pls decimal-point
      char c = Serial.read();  //gets one byte from serial buffer
      if (isdigit(c)) { // Is it a digit (0-9)
        readString += c; //makes the String readString
        Serial.println(readString);
        delay(2);  //slow looping to allow buffer to fill with next character
      }// end if isdigit
      else
      {
        Serial.println("Skip decimal point");
        char c = Serial.read();  //gets one byte from serial buffer
      }// end of else is digit
    }// end for-loop
  }// end while
  Serial.print("*");
}// end getServovalue()```
Deze worden beide getoond, waarbij het lijkt dat er binnen de routine niets word uitgevoerd. Misschien helpt jou dat

HI…

Je doet hier while (Serial.available()), waarmee je controleert of er een seriele byte beschikbaar is.
Wat nu als er geen byte in dat buffertje zit ?

In je nieuwe code (snippet) word er dan een dollarteken (de forumsoftware verwijdert het ding ?) voor aanvang van de while gestuurd, en een * na afloop van de while.
In je beschrijving heb ik niets gezien over het sterretje, maar ik zie wel dat je zegt dat ‘beide’ getoond worden.
Als je zowel een $ als een * ziet, dan was het buffer dus leeg, en gaat je sketch verder met wat er dan gedaan moet worden (terug naar loop() ).
Aangezien we al weten dat de seriële verbinding werkt (want anders waren we nooit in deze functie genaamd getServovalue beland), hoeven wel daar ook niet meer per se op te controleren.
Dus schakelen we dat maar eens uit door er // voor te zetten.
Omdat je voor het lezen c steeds opnieuw creëert, zal die leeg zijn.
Daarom kun je dit ook gebruiken om te blijven kijken naar de com port, totdat jouw getal-buffer gevuld is met 6 karakters.
Vergeet niet ook te kijken naar de punten en de komma’s die men zou kunnen intypen.

Overigens laat deze functie de data wel meteen weer vervliegen zodra de functie verlaten word.
Uiteraard kan dat opgelost worden.

Bedankt voor je uitleg, maar dit is allemaal veel te theoretisch voor mij…
Moet ik de whilke anders schrijven, zoja heb je een code voorbeeld

Dit is het behoorlijk bijgewerkte stukje code dat je t laatst liet zien:

String readString;
#define isdigit(X) (((X) >= '0') && ((X) <= '9'))
Serial.println("Enter value(0-180 at.5 interval");
Serial.print("$");
//while (Serial.available()) {  Deze regel is nu uitgeschakeld
for (int idx = 0; idx < 4; idx++) { // Get 4 numbers pls decimal-point, we starten bij nul
  char c = Serial.read();  //gets one byte from serial buffer
  if (isdigit(c) || c == "," || c == ".") { // Is it a digit (0-9) of een komma of een punt
    if (c == ",") c = "."; // we maken van een eventuele komma een punt
    readString [idx] = c; //makes the String readString
    readString [idx + 1] = '\n'; // Voeg alvast het afsluitende nul teken toe aan de array
    Serial.println(readString);
    delay(2);  //slow looping to allow buffer to fill with next character
  }// end if isdigit
  else
  {
    //    Serial.println("Skip decimal point");
    //    char c = Serial.read();  //gets one byte from serial buffer
    idx--;  // Dit was geen juist teken, die gaan we niet meetellen
  }// end of else is digit
}// end for-loop
//  }// end while    Deze afsluiter hoort bij de uigeschakelde regel, en nu dus ook uitgeschakeld
Serial.print("*");
return readString;  // We geven de ingetypte string terug aan de rest van de code
}// end getServovalue()

In dit stukje ga je alle toetsaanslagen bekijken, en wanneer het een cijfer, een komma of een punt is, voeg je 'm toe aan je waarde (een komma word dan wel eerst omgezet naar een punt).
Om dat te kunnen doen, moeten we wel een andere aanpak gaan volgen.
Want eerder telde je de ASCII waardes van hetgeen getypt werd, op.
Dan krijg je dus als resultaat van jouw voorbeeld waarde “123.4”: (49 + 50 + 51 + 46 + 52 = ) 248 (dat is het graden symbool als in graden celsius).
Wat je wil is een rijtje tekens maken, en zo’n rijtje heet een array.
Daarom begin ik nu in de index met tellen bij nul, en ga tot 4 (dat is een totaal van 5 items).
De index geeft nu ook aan welk karakter in je array je wil bewerken, en daarom is het noodzakelijk dat je bij nul begint (en de reden waarom ik het daar eerder al over had).
Omdat je teller wel elke keer wordt opgehoogd, moet je deze weer een stapje terugzetten wanneer het binnengekomen teken niet binnen de toegestane waardes valt.
Zo word er alleen geteld als er wel een passende waarde werd toegevoegd.
Helemaal perfect is het niet, want je kunt nu ook bijvoorbeeld de waarde “12…” als resultaat krijgen.
Maar daar is natuurlijk ook nog wel wat aan te doen.

Deze code is heel leuk om aan te werken en dan uiteindelijk te zien dat je in je terminal programma ook wat ziet veranderen, maar erg veel heb je er niet aan.
Wil je met de ingetypte waarde ook wat gaan doen, dan moet je die waarde teruggeven uit deze functie aan de functie doe 'm aanriep.
Loop() in dit geval.
Dat doe je met return, onderaan de code.
Maar dan moet je wel wat terugverwachten tijdens dat aanroepen, dat doe je nu denk ik niet.

In je eerste bericht roep staat het stukje waar ik dat op baseer, en dat zou dan moeten veranderen in iets als:

char Ingetypt[5] = getServovalue

Hierna zal dus de string “123.4” (om bij het voorbeeld te blijven) in de variabele Ingetypt terecht komen en binnen loop() gebruikt kunnen worden.

Verder is het natuurlijk zo dat wanneer je eenmaal het laatste teken hebt ingevoerd, de functie meteen is afgelopen.
Dus wanneer dat laatste teken een vergissing was, heb je vette pech.

Als laatste: Dit is een aanpassing op het stukje code dat je het laatst geplaatst hebt, en een klein deel van de code uit je eerste post.
Ik heb het zo goed mogelijk gecontroleerd, maar ik kan het niet compileren omdat ik niet de hele code heb (bijvoorbeeld die includes).
Dus of het 100 % klopt weet ik niet.

Ik heb de code zo aanmgepst dat all eigen includes er uit zijn.

#include <Arduino.h>
#include <Streaming.h>  /* http://arduiniana.org/libraries/streaming/ */
#include "String.h"

//#define   KEY_MOVE_LC     0x60
//#define   KEY_MOVE_UC     0x40
#define   KEY_XAXIS_LC    0x78
#define   KEY_XAXIS_UC    0x58
#define   KEY_YAXIS_LC    0x79
#define   KEY_YAXIS_UC    0x59
#define isdigit(X) (((X) >= '0') && ((X) <= '9'))

boolean   recvByte    = false;
boolean   gotMove     = false;
boolean   gotAxis     = false;
boolean   newData     = false;
String inData;
String comdata          = "";

void setup() {
  Serial.begin(9600);
  Serial.println("Serial conection started, waiting for a command...");
  Serial.print(">");
}// end setup

void loop() {
  while (Serial.available() > 0)
  {
    char recieved = Serial.read();
    switch (recieved) {
      case 'm':
      case 'M':
        gotMove = true;
        Serial.println("Move to: ");
        char servoMoveto[5] = getServovalue();
        // This line gives eror
        //array must be initialized with a brace-enclosed initializer
        Serial.println(servoMoveto);
        break;
      case 'x':
      case 'X':
        gotAxis = true;
        Serial.println("Move X-Axis servo ");
        break;
      case 'y':
      case 'Y':
        gotAxis = true;
        Serial.println("Move Y-Axis servo ");
        break;
      default:
        gotAxis = false;
        gotMove = false;
        Serial.println("Invalid command");
        break;
    }// end switch
  }// while
}// end loop



void getServovalue() {
  Serial.println("Enter value(0-180 at.5 interval");
  Serial.print("?");
  String readString;
#define isdigit(X) (((X) >= '0') && ((X) <= '9'))
  Serial.println("Enter value(0-180 at.5 interval");
  Serial.print("$");
  //while (Serial.available()) {  Deze regel is nu uitgeschakeld
  for (int idx = 0; idx < 4; idx++) { // Get 4 numbers pls decimal-point, we starten bij nul
    char c = Serial.read();  //gets one byte from serial buffer
    if (isdigit(c) || c == "," || c == ".") { // Is it a digit (0-9) of een komma of een punt
      if (c == ",") c = "."; // we maken van een eventuele komma een punt
      readString [idx] = c; //makes the String readString
      readString [idx + 1] = '\n'; // Voeg alvast het afsluitende nul teken toe aan de array
      Serial.println(readString);
      delay(2);  //slow looping to allow buffer to fill with next character
    }// end if isdigit
    else
    {
      //    Serial.println("Skip decimal point");
      //    char c = Serial.read();  //gets one byte from serial buffer
      idx--;  // Dit was geen juist teken, die gaan we niet meetellen
    }// end if else is digit
  }// end for-loop
  //  }// end while    Deze afsluiter hoort bij de uigeschakelde regel, en nu dus ook uitgeschakeld
  Serial.print("*");
  return readString;  // We geven de ingetypte string terug aan de rest van de code
}// end getServovalue()
//}// end void getServovalue```

De aanroep naar jouw advies aangepast. Dit geeft echter een foutmelding.

De waarde 123.4 mag ook rustig als 1234 geretourneerd worden, dan hoef ik verder niet met breuken te werken(vreemde afrondingen).
Fijn weekeinde

Streaming.h moest ik ook weghalen, want dat ding heb ik ook niet.

De call moet zijn:

        char servoMoveto[5] = {getServovalue()};

Ik had dus de {} over het hoofd gezien.
En voor de functie moet dan ook char staan.
Maar dan nog gaat er iets niet helemaal lekker :sweat_smile:

Heb je uiteindelijk een getal, of een string nodig ?
Want het lijkt er op dat er ook nog een conflict door vergelijken van de string met wat anders ontstaat, en daarbovenop komt er nog een ander probleem bovendrijven.
Wanneer je met het getal float 123.4 of int 1234, dus niet de string “123.4” ook (of beter) uit de voeten kunt, dan kun je beter het geheel eerst converteren van string naar de floating point of integer.
Afhankelijk van het antwoord kan er verder gewerkt worden an de sketch.

Ik krig nu de foutmelding:
void value not ignored as it ought to be
Dit zegt mij dus niks.

Het getal mag w.m.b. ook een int zijn, het mag nooit <0 of >180 worden. Dus stuur ik b.v. 1234/10 naar de servo.
Ik ben er nog niet uit of ik graden of millisecends ga gebruiken.

OK dan kun je het best een float gebruiken, zodat je ook kunt delen door 10 en een getal achter de komma over houdt.
Ik kan wel wat proberen te bakken, maar dat word dan iets minder efficiënt in verband met geheugen.
Dus als je code groot word, kan het zijn dat er een betere oplossing bedacht moet worden.
Je sketch zal hierdoor wel redelijk sterk veranderen, en ik weet nog niet wanneer ik voldoende tijd heb gehad om de verandering te maken.

Deze code compileert (als ik include streaming weglaat):

#include <Arduino.h>
#include <Streaming.h>  /* http://arduiniana.org/libraries/streaming/ */
#include "String.h"

//#define   KEY_MOVE_LC     0x60
//#define   KEY_MOVE_UC     0x40
#define   KEY_XAXIS_LC    0x78
#define   KEY_XAXIS_UC    0x58
#define   KEY_YAXIS_LC    0x79
#define   KEY_YAXIS_UC    0x59
#define isdigit(X) (((X) >= '0') && ((X) <= '9'))

boolean   recvByte    = false;
boolean   gotMove     = false;
boolean   gotAxis     = false;
boolean   newData     = false;
String inData;
String comdata        = "";
float servoMoveto     = -1; // We maken een globale floating point variabele


void setup() {
  Serial.begin(9600);
  Serial.println("Serial conection started, waiting for a command...");
  Serial.print(">");
}// end setup

void loop() {
  while (Serial.available() > 0)
  {
    char recieved = Serial.read();
    switch (recieved) {
      case 'm':
      case 'M':
        gotMove = true;
        Serial.println("Move to: ");
        getServovalue;
        Serial.println(servoMoveto);
        break;
      case 'x':
      case 'X':
        gotAxis = true;
        Serial.println("Move X-Axis servo ");
        break;
      case 'y':
      case 'Y':
        gotAxis = true;
        Serial.println("Move Y-Axis servo ");
        break;
      default:
        gotAxis = false;
        gotMove = false;
        Serial.println("Invalid command");
        break;
    }// end switch
  }// while
}// end loop



void getServovalue() {
  servoMoveto = 0;  // We resetten de waarde zodat we een nieuwe waarde kunnen ingeven
  Serial.println("Enter value(0-180 at.5 interval");
  Serial.print("?");
  String readString;
#define isdigit(X) (((X) >= '0') && ((X) <= '9'))
  Serial.println("Enter value(0-180 at.5 interval");
  Serial.print("$");
  //while (Serial.available()) {  Deze regel is nu uitgeschakeld
  for (int idx = 0; idx < 3; idx++) { // Get 4 numbers, we starten bij nul
    servoMoveto = (servoMoveto * 10); // We schuiven 1 decimaal op wanneer we minstens 1 waarde hebben ingevuld
    float c = Serial.read();  //gets one byte from serial buffer
    if (isdigit(c)) {   // Is it a digit (0-9)
      c = (c - 48);     // Converteer de ASCII waarde naar het betreffende getal
      servoMoveto = (servoMoveto + c);  //Tel de nieuwe waarde op bij de oudere waarde
      Serial.println(servoMoveto);
      delay(2);  //slow looping to allow buffer to fill with next character
    }// end if isdigit
    else
    {
      //    Serial.println("Skip decimal point");
      //    char c = Serial.read();  //gets one byte from serial buffer
      idx--;  // Dit was geen juist teken, die gaan we niet meetellen
    }// end if else is digit
    servoMoveto = (servoMoveto / 10);
  }// end for-loop
  //  }// end while    Deze afsluiter hoort bij de uigeschakelde regel, en nu dus ook uitgeschakeld
  Serial.print("*");
}// end getServovalue()
//}// end void getServovalue

De aanpassing viel nog mee.
Ik weet niet zeker of alles werkt, want dan moet ik het in een Arduino schieten om te proberen.
Maar ik denk dat het een aardig eind de goede kant op zal zijn.

Het is de bedoeling een getal als ASCII waarde binnen te halen in plaats van een teken in een string.
Het binnengehaalde getal maken we dan een 4 tallig nummer, tenzij de eerste cijfers een nul zijn.
Nadat alle cijfers zijn ingevoerd, word het resultaat gedeeld door 10.
Zo kun je dus ook 0040 opgeven om op 4.0 uit te komen.
Omdat dit in een globale variabele word gezet, kun je het resultaat zowel in loop() als in een andere functie zoals getServovalue() gebruiken en/of bewerken.
Hoe je dat dan uiteindelijk in een waarde transformeert die voor je servo gebruikt kan worden weet ik ook niet, daar mag je nog mee aan de slag.

[edit]
Oh, volgens mij heb je nu String.h en readString ook niet meer nodig.
Dus die kun je eventueel ook nog weghalen door er commentaar regels van te maken, gaat je ook wat geheugen besparen.
[/edit]

De sketch compileerd nu goed nadat ik de waarde servoMoveto als int heb gedeclareerd.

//String comdata          = "";
int servoMoveto;

void setup() {

Echter 123.4 wordt niet :slight_smile: Serial conection started, waiting for a command…

Move to:
Enter value(0-180 at.5 interval
?Enter value(0-180 at.5 interval
$1
2
3
*Invalid command

Je ziet ook dat de eerste regel twee maal wordt getoond. daar heb ik geen verklaring voor.

Pff

Ja dat komt door println, daar heb ik helemaal niet op gelet.
Die moet je veranderen in print, zodat er niet naar de volgende regel gesprongen word:

 Serial.print(servoMoveto);

Ik zal straks nog even verder kijken.

Nou toch maar even een Uno’tje erbij gepakt.
Je hebt schijnbaar zelf bovenaan in de functie getServovalue een aantal regels gekopieerd, daardoor krijg je 2 keer hetzelfde te zien.
Verder zat er nog iets niet goed in het verwerken van de commando’s want bij het commando m gebeurt er niets, en bij het commando M wel.
Daarom heb ik bij beiden hetzelfde gemaakt, anders gaat je sketch foute resultaten tonen (de reden waarom ik servoMoveto met -1 (een onmogelijke waarde) initialiseer).

Regel 76 doet niets, maar als ik die weghaal dan werkt die functie niet meer en ik heb geen idee waarom dat zo is.
Je ziet dat dezelfde code op regel 80 herhaald word, en dan werkt het ineens zoals bedoeld maar zonder die regel (die kan ook op andere plaatsen na regel 76 worden ingevoegd) gaat het op dezelfde manier fout als wanneer regel 76 word weggehaald.
Helaas werkt het met de IDE Serial Monitor en met Putty niet dat je terug kunt springen naar het begin van de regel; de af te beelden tekst komt er dan gewoon achteraan in plaats van er overheen.
Dus carriage return werkt niet, carriage return / line feed werkt wel maar das eigenlijk niet wat we zouden willen.
Verder werkt het volgens mij nu wel zoals bedoeld, inclusief 1 decimaal (zonder een punt of komma in te geven).
Wanneer je dat wil afronden, kun je dat doen door er eerst 0.5 bij op te tellen en er dan een een int te vullen met de waarde uit je float.

Dit is de code die (bij mij) werkt voor wat betreft het ingeven van je waarde.
Hoe je daar verder mee om zult gaan naar je servo toe mag je weer verder oppikken.

#include <Arduino.h>
//#include <Streaming.h>  /* http://arduiniana.org/libraries/streaming/ */
#include "String.h"

//#define   KEY_MOVE_LC     0x60
//#define   KEY_MOVE_UC     0x40
#define   KEY_XAXIS_LC    0x78
#define   KEY_XAXIS_UC    0x58
#define   KEY_YAXIS_LC    0x79
#define   KEY_YAXIS_UC    0x59
#define isdigit(X) (((X) >= '0') && ((X) <= '9'))

boolean   recvByte    = false;
boolean   gotMove     = false;
boolean   gotAxis     = false;
boolean   newData     = false;
String inData;
String comdata        = "";
float servoMoveto     = -1; // We maken een globale floating point variabele


void setup() {
  Serial.begin(9600);
  Serial.println("Serial connection started, waiting for a command...");
  Serial.print(">");
}// end setup

void loop() {
  while (Serial.available() > 0)
  {
    char recieved = Serial.read();
    switch (recieved) {
      case 'm':
        gotMove = true;
        Serial.println("Move to: ");
        getServovalue();
        Serial.println(servoMoveto);
        break;
      case 'M':
        gotMove = true;
        Serial.println("Move to: ");
        getServovalue();
        Serial.println(servoMoveto);
        break;
      case 'x':
      case 'X':
        gotAxis = true;
        Serial.println("Move X-Axis servo ");
        break;
      case 'y':
      case 'Y':
        gotAxis = true;
        Serial.println("Move Y-Axis servo ");
        break;
      default:
        gotAxis = false;
        gotMove = false;
        Serial.println("Invalid command");
        break;
    }// end switch
  }// while
}// end loop



void getServovalue() {
  servoMoveto = 0;  // We resetten de waarde zodat we een nieuwe waarde kunnen ingeven
  Serial.println("Enter value(0-180 at.5 interval)");
  Serial.println("?");
  String readString;
#define isdigit(X) (((X) >= '0') && ((X) <= '9'))
  //  Serial.println("Enter value(0-180 at.5 interval");
  Serial.println("$");
  //while (Serial.available()) {  Deze regel is nu uitgeschakeld
  for (int idx = 0; idx < 4; idx++) { // Get 4 numbers, we starten bij nul
    servoMoveto *= 10; // Het spookt hier, wanneer deze regel verandert, gaat het fout
    int c = Serial.read();  //gets one byte from serial buffer
    if (isdigit(c)) {   // Is it a digit (0-9)
      c -= 48;     // Converteer de ASCII waarde naar het betreffende getal
      servoMoveto *= 10; // We schuiven 1 decimaal op wanneer we minstens 1 waarde hebben ingevuld
      servoMoveto = (servoMoveto + c);  //Tel de nieuwe waarde op bij de oudere waarde
      Serial.println(servoMoveto);
      delay(2);  //slow looping to allow buffer to fill with next character
    }// end if isdigit
    else
    {
      //    Serial.println("Skip decimal point");
      //    char c = Serial.read();  //gets one byte from serial buffer
      idx--;  // Dit was geen juist teken, die gaan we niet meetellen
    }// end if else is digit
    servoMoveto = (servoMoveto / 10);
  }// end for-loop
  //  }// end while    Deze afsluiter hoort bij de uigeschakelde regel, en nu dus ook uitgeschakeld
  Serial.print("*");
}// end getServovalue()
//}// end void getServovalue

Sory voor het late antwoord, maar met jouw advies van gisteren ben ik vandaag eens bezig gegaan.
Heb de routine omgebouwd naar een int en dat is mij aardig gelukt met maar 6 regels in de IDE.

#include <Streaming.h>  /* http://arduiniana.org/libraries/streaming/ */
//#include "String.h"

//#define   KEY_MOVE_LC     0x60
//#define   KEY_MOVE_UC     0x40
#define   KEY_XAXIS_LC    0x78
#define   KEY_XAXIS_UC    0x58
#define   KEY_YAXIS_LC    0x79
#define   KEY_YAXIS_UC    0x59
#define isdigit(X) (((X) >= '0') && ((X) <= '9'))

boolean   recvByte    = false;
boolean   gotMove     = false;
boolean   gotAxis     = false;
boolean   newData     = false;
//String inData;
//String comdata          = "";
int servoMoveto;
char servoString[5];

void setup() {
  Serial.begin(9600);
  Serial.println("Serial conection started, waiting for a command...");
  Serial.print(">");
}// end setup

void loop() {
  while (Serial.available() > 0)
  {
    char recieved = Serial.read();
    switch (recieved) {
      case 'm':
      case 'M':
        gotMove = true;
        servoMoveto = 0;
        //        servoString = '     ';
        Serial.println("Move to: ");
        int servoValue = {getServovalue()};
        Serial.println(servoValue);
        break;
      case 'x':
      case 'X':
        gotAxis = true;
        Serial.println("Move X-Axis servo ");
        break;
      case 'y':
      case 'Y':
        gotAxis = true;
        Serial.println("Move Y-Axis servo ");
        break;
      default:
        gotAxis = false;
        gotMove = false;
        Serial.println("Invalid command");
        break;
    }// end switch
  }// while
}// end loop

int getServovalue() {
  int servoValue = 0;
#define isdigit(X) (((X) >= '0') && ((X) <= '9'))
  Serial.println("Enter value(0-180 at.5 interval");
  Serial.print("=>");
  for (int idx = 0; idx < 4; idx++) { // Get 4 numbers, we starten bij nul
    int c = Serial.read();  //gets one byte from serial buffer
    if (isdigit(c)) {   // Is it a digit (0-9)
      c = (c - 48);     // Converteer de ASCII waarde naar het betreffende getal
      servoValue = servoValue * 10;// multiply by 10 to create int
      servoValue = servoValue + c; // add LSDigit
      Serial.print(c); // show received diti
      //      Serial << "=>" << c << "\t" << servoValue << endl;// use to check
    } else {
      idx--;
      //      Serial.print("#>");
    }
  }
  return (servoValue);
}```
Nu moet ik alleen nog uitvogelen hoe ik de gebruikrt de punt die nu niet getoond wordt, te toonen

Kijk even in mijn bericht net boven jouw laatste bericht, van afgelopen nacht.

Dank voor je info. Als terminal gebruik ik TerraTerm. Dit omdat de Arduino IDE geen enkele tekens verstuurd en alles afgesloten moet worden met een CR.

Ben ondertussen verder gegaan met de routine:

  int servoValue = 0;
#define isdigit(X) (((X) >= '0') && ((X) <= '9'))
  Serial.println("Enter value(0-180 at.5 interval");
  Serial.print("=>");
  for (int idx = 0; idx < 4; idx++) { // Get 4 numbers, we starten bij nul
    int c = Serial.read();  //gets one byte from serial buffer
    if (isdigit(c)) {               // Is it a digit (0-9)
      c = (c - 48);                 // Converteer de ASCII waarde naar het betreffende getal
      servoValue = servoValue * 10; // multiply by 10 to create int
      servoValue = servoValue + c;  // add LSDigit
      Serial.print(c);              // show received diti
    }
    else if (c == '.' || c == ',') {
      //If . or , received print decimalpoint
      Serial.print(".");            // show received diti
      idx = 2;                      // digit before decimalpoint
      // this covers also nonleading zero's
      //if the userinput looks like 12.4 or 1.4 and .4
    }
    //    else if(c == "\b") { // dit wordt niet herkent(/b)
    else if (c == 0x08) {
      if (idx >= 0) {
//        Serial << idx;
        Serial << "\b";
        idx--;
        idx--;
      }
    }
    else {
      idx--;
    }
  }
  return (servoValue);
}// end void getServovalue

Het latste deel is voorlopig.
Ik denk aan de volgende aanpasingen:
Als idx de waarde 3 bereikt wordt op de terminal een . geprint (kan de gebruiker geen grrot getal invoeren, bv 12345
Verder moet ik nog testen dat de returnwaarde niet <0 of >180 wordt en hoe de correctie na de decimale punt moet functioneren. Groetjes

De limieten voor je waardes is niet zo heel lastig.
Je kunt gewoon servoValue testen of ie binnen de door jou gewenste waardes zit, en het ingegeven getal weigeren als dat niet zo is.
Of je dat binnen of na de functie getServovalue doet maakt niet zo heel veel uit.
Ik heb ook geen idee waarom je een decimaal na de punt wil, want het is mij niet bekend dat je een servo zo nauwkeurig kunt sturen.
Maar het is jouw feestje.

Werkt de backspace ?