Hoi,
Wie helpt me op weg.
Ik gebruik een filghtsim condor die UDP output geeft.
Via serial.read krijg ik eea binnen maar kan niet zien wat exact via serial monitor.
De software die de hex data omzet geeft dus een andere input da de hex data zelf.
Hoe ontleed ik z2 en z3 in bruikbare gatellen om een servo aan te sturen?
Zie afbeelding
alvast dank
De "preview (values)" komt goed overeen met de aangevinkte hokjes bij "UDP preview", maar met meer decimalen. Als je de hex-getallen vertaalt naar decimaal krijg je dit:
112 112 112 112 112 112
106 2 43 5 47 68
106 3 10 140 53 58
Ik herken daar alleen de cijfers 2 en 3 in, en ik neem aan dat de volgende 4 getallen op elke regel de waarde voorstellen, al weet ik nog niet hoe...
Kun je eens laten zien wat er op je serial monitor komt? En dan liefst de ASCII-waarde van de tekens!
Hoi.
Ik begrijp niet veel van jouw vraag.
Maar wanneer je hexadecimale waardes gaat verzenden en die ontvangt in een serial monitor, dan worden die hexadecimalen omgezet naar ASCII tekens.
Daarom krijg je dan allerlei onherkenbare zooi te zien.
In dit geval raad ik je aan om de binnenkomende data met een ander programma te bekijken, zoals bijvoorbeeld RealTerm.
Daar kun je op het 1e tabblad (Display) kiezen voor Hex(space), dan zie je het op dezelfde wijze gepresenteerd zoals 78 78 bijvoorbeeld.
ASCII 7A is bijvoorbeeld de z.
De waarde die daarna komt wordt in je tabel als getal weergegeven om aan te geven welke z waarde je binnenkrijgt.
Dus z2 en z3.
De inhoud is dan dus 2B 05 2F 44.
Ik weet niet of de laatste waarde (44) een checksum is, en heb ook geen idee hoe je die waardes omrekent naar het getal waar je naar op zoek bent.
Je moet aan de condor community (als die er is) vragen hoe dit in elkaar zit.
78 is een x.
6 maal een x achter elkaar betekent waarschijnlijk dat er een nieuwe riedel komt.
En een z dus dat er een nieuwe regel komt en de volgende waarde is welke uit alle mogelijke er aan komt.
Meer kan ik er niet van maken.
Erik_Baas:
De "preview (values)" komt goed overeen met de aangevinkte hokjes bij "UDP preview", maar met meer decimalen. Als je de hex-getallen vertaalt naar decimaal krijg je dit:112 112 112 112 112 112
106 2 43 5 47 68
106 3 10 140 53 58
z2 en z3 repectievelijk meters in hoogte en stijging/daling in meter per seconde.
Dus hoogte 700.0 meter, stijging/daling 0.0 meter per seconde.
Van die waardes heb ik alleen 1 decimaal nodig.
Ik herken daar alleen de cijfers 2 en 3 in, en ik neem aan dat de volgende 4 getallen op elke regel de waarde voorstellen, al weet ik nog niet hoe... Kun je eens laten zien wat er op je serial monitor komt? En dan liefst de ASCII-waarde van de tekens! Gaat niet omdat de comm poort reeds bezet is.
Dit is het origineel:
#include <Servo.h> // link to the servo library.
#include <Wire.h> // needed for the liquid crystal display (LCD)
#include <Stepper.h>
#define motorPin1 8 // IN1 on the ULN2003 driver
#define motorPin2 9 // IN2 on the ULN2003 driver
#define motorPin3 10 // IN3 on the ULN2003 driver
#define motorPin4 11 // IN4 on the ULN2003 driver
#define Servopin 4 // Pin 4 PWM on Arduino
#define STEPS (315*3) // 945
// the x27 stepper lists 1/3deg per step.=3 steps per deg = 3*360 steps per full rotation = 1080 steps per revolution.
// 1080/360*315 (max) = 945.
const int X27StepsPerRevolution = 1080;
const int maxSteps = 945; // X27 can only turn 315°
Servo MyServo; // define an object of servomotor
//Servo MyServo2; // define an object of servomotor
// *********************************************
// My Servo is a Hitec HS-211 servo. Not the fastest but for prototyping it will do.
// Datasheet shows Max Travel (out of box)202 deg
// Vario Range will be -5 <> +5
// range 10 m/s for 200 deg
// 1 m/s = 20 deg of travel
// zero point = 100
// + 5 m/s = 5 * 20 + 100 = 200
// -5 m/s = -5 * 20 + 100 = 0
// X m/s = X * StpVario + 100;
// 1 step = 0,05 m/s
//
//-1.3 m/s = -1.3 * 20 +100 = -26+100=74
//-1.4 m/s = -1.4 * 20 + 100 =-28+100=72
// *********************************************600
int StepVario = 20; // 1 ms/s = 20 steps on the servo --> 0.1 m/s = 2 steps on the servo
Stepper ACSpeedStepper(X27StepsPerRevolution, 8, 9, 10, 11);
bool homing = false;
bool ServoOn = true;
int altl, spdl, hdgl, bnkl, pitl, varrl, varel, varil, gfol, yawl;
int alth, spdh, hdgh, bnkh, pith, varrh, vareh, varih, gfoh, yawh;
int alt, spd, hdg, bnk, pit;
double varr, vare, vari, gfo, yaw;
int spdval, pos;
int maxspeed = 300;
int maxsteps = 630;
void setup()
{
if (ServoOn)
{
MyServo.attach(Servopin); // my servo is attached to pin 7
MyServo.write(100);// Range is 0-200. Zero point is halfway = 100
//MyServo2.attach(6); // my s2nd servo is attached to pin 6
//MyServo2.write(100);// Range is 0-200. Zero point is halfway = 100
}
pos = 0;
spdval = 0;
ACSpeedStepper.setSpeed(25);
ACSpeedStepper.step (-1 * maxsteps);
Serial.begin(19200);
}
void loop()
{
if (Serial.available() > 0) // there is data in the buffer
{
if (Serial.available() > 21) // wait until it is filled with all the bytes we need. (21 total)
{
if (Serial.read() == 255) //we found the start serialdata[0]
{
altl = Serial.read();//serialdata[1] // read altitute
alth = Serial.read();//serialdata[2]
spdl = Serial.read();//serialdata[3]// read speed
spdh = Serial.read();//serialdata[4]
hdgl = Serial.read();//serialdata[5]// read compass
hdgh = Serial.read();//serialdata[6]
pitl = Serial.read();//serialdata[7]// read pitch
pith = Serial.read();//serialdata[8]
bnkl = Serial.read();//serialdata[9]// read bank
bnkh = Serial.read();//serialdata[10]
varrl = Serial.read();//serialdata[11] // read vario raw
varrh = Serial.read();//serialdata[12]
varel = Serial.read();//serialdata[13]// read vario elec
vareh = Serial.read();//serialdata[14]
varil = Serial.read();//serialdata[15]// read vario integrated
varih = Serial.read();//serialdata[16]
gfol = Serial.read();//serialdata[17]// read Gforce
gfoh = Serial.read();//serialdata[18]
yawl = Serial.read(); //serialdata[19] // read yawstringangle
yawh = Serial.read(); //serialdata[20]
//All is read --> convert the bytes into proper data
alt = altl << 8 | alth; //decode altitude (m)
spd = spdl << 8 | spdh; //decode speed (in kmph)
hdg = hdgl << 8 | hdgh; //decode compass (deg)
pit = (pitl << 8 | pith) - 90; //decode pitch (deg)
bnk = (bnkl << 8 | bnkh) - 180; ////decode bank (deg)
varr = ((varrl << 8 | varrh) / 10.0) - 100.0; //decode raw vario (m/s)
vare = ((varel << 8 | vareh) / 10.0) - 100.0; //decode elec vario (m/s)
vari = ((varil << 8 | varih) / 10.0) - 100.0; //decode integrated vario (m/s)
gfo = ((gfol << 8 | gfoh) / 10.0) - 10.0; //decode gforce
yaw = ((yawl << 8 | yawh)) - 50.0; //decode yawstringangle (deg) [-99,99] but more in the range of [-10 , 10]
if (spd > maxspeed) spd = maxspeed;
spdval = map(spd, 0, maxspeed, 0, maxsteps);
if (vari < -5) vari = -4.9;
if (vari > 5) vari = 4.9;
}
}
}
//Set the Speeddial
//*****************
if (abs(spdval - pos) >= 2)
{ //if diference is greater than 2 steps.
if ((spdval - pos) > 0)
{
ACSpeedStepper.step(+1); // move one step to the right.
pos++;
}
if ((spdval - pos) < 0)
{
ACSpeedStepper.step(-1); // move one step to the left.
pos--;
}
}
// Set the VARIO
//*****************
if (ServoOn)
{
MyServo.write(varr * StepVario + 100); //0.1 m/s *20 +100 = 102
//MyServo2.write(vari * StepVario + 100); //
}
}//end loop
Dat origineel, is dat een sketch die de data correct verwerkt ?
Want dat strookt volgens mij namelijk niet met wat er in jouw plaatje te zien is.
Even snel een korte uitleg (ik heb geen idee of je dit al weet of niet):
Hexadecimaal betekent een 16-tallig tel systeem.
Wij hebben allemaal op onze vingers leren tellen, en de meeste mensen hebben er daar 10 (decimaal) van.
Hexadecimale nummer gaan van 0 tot en met F, na de 9 komt A en zo voorts.
Zoals je in jouw afbeelding kunt zien, worden die hexadecimale getallen per 2 gecombineerd.
Dan heb je 16 maal 16 mogelijkheden; 256 in totaal.
Jouw seriële verbinding werkt ook met bytes, en de ASCII tabel (waarin tekens volgens afspraken staan) werkt met 256 mogelijke tekens.
Zoals eerder gezegd, de seriële verbinding verzendt ASCII tekens.
De code die je nu toont haalt waardes binnen in met telkens 2 ASCII tekens:
altl = Serial.read();//serialdata[1] // read altitute
alth = Serial.read();//serialdata[2]
Das dus een lage digit (noem ik ze maar bij gebrek aan een betere benaming die er ongetwijfeld wel is) en een hoge digit, en samen bieden die ruimte voor 256 maal 256 mogelijkheden; dat zijn er in totaal 65536.
Ik meen dat het geheel dan een woord heet.
Tijdens de sketch word alles overgeslagen tot er een waarde van 255 binnenkomt.
Daarna worden een voor een de ASCII tekens binnen gehaald en eerst in een lage digit en dan in een hoge digit gezet.
Ik heb geen idee waar die if.. statement voor nodig is die kijkt of er 21 digits zijn binnen gekomen.
Want das pas interessant als je weet waar het begin precies zit.
Dus pas na de start digit van 255 kun je gaan tellen en weten wat je binnenkrijgt.
In totaal worden er 10 waarden verwacht, maar het lijstje met waarden die gekozen kunnen worden is bij nummer 12 die nog zichtbaar is, nog niet halverwege de gehele lijst.
Maar goed.
De data die in het venstertje "serial data preview" vermeld staan, komen niet overeen met deze werkwijze.
Maar als die sketch wel werkt, dan komt dus alleen een start signaaltje binnen en vervolgens 10 registers (ook de niet relevante).
Ik heb nog steeds geen idee hoe je dan de 65536 maximaal beschikbare waarden, moet schalen naar de gewenste weergaven.
Maar wanneer je van iedere grootheid die je binnen krijgt weet wat de minimale en de maximale waarde is, kun je dat dus zelf vaststellen en verwerken.
Nogmaals, wanneer je een seriële monitor gebruikt die de hex waarden laat zien, kun je wellicht meer te weten komen.
Dan ga je analyseren of je inderdaad steeds 20 hex waarden tegen komt tussen FF en FF.
Anders wordt het analyseren een wat grotere uitdaging, en val ik eerst terug op wat ik eerder zei over de z (7A) en een serie x'en (78).
Dank je voor de duidelijke uitleg.
Ik heb een lcd aangesloten om te de comm poort te monitoren.
Het werkte niet omdat ern geen data binnenkwam van de sim.
Middels een prgogrammatje dat de pc poort uitleest en data van de sim naar de comm poort stuurt werkt het nu.
Nogmaals dank.