Super Simple Sound Doppler Peiler

[Goos]

@Lodewijk

Als je de funtie atn2 gebruikt hoef je alleen maar <0 af te vangen, zal niet >=360 worden als je tenminste geen ceiling() o.i.d. gebruikt

Ben benieuwd wat voor snelheid je haalt , ik kwam met mijn progje niet ver boven de 100Hz.
De processor heeft geen floatingpoint berekeningen aan boord voor zover ik weet. daarom ook alleen geschikt gemaakt voor 4 antennes

Het scf in het schema begrijp ik niet, tenminste niet samen met het progje.

gr
Goos

[pa0ejh]

Mogelijk zou de Teensy sneller zijn, 48Mhz en 12 bits ADC en hardwareTimers..

https://www.pjrc.com/teensy/teensyLC.html

[Dopp]

Hallo Allemaal,


Alvast een plaatje van de MyMapping1.54 met doorzichtige Pelorus en tweede Arduino terminal

Beide terminals (Standaard Terminal en Arduino) decoderen GPS NMEA en Agrelo

Dus dan kan de GPS aan de standaard seriele poort en de arduino aan de tweede seriele bv.

De terminal Arduino heeft ook echter knoppen en een send command line(geel) in MyMapping1.54

Met een calibratie schuif balk en een CW / CWW knop.
(In de Arduino sketch veranderd dat alleen 2 antPins in de array van plaats

Input string is een serial.read() van de compoort natuurlijk.


byte swap;
byte antPin[]={1,2,3,4};

if (inputstring =="CW"){
swap = antPin[1];
antPin[1]=antPin[3];
antPin[3]=swap;
}

if (Inputstring =="CCW"){
swap = antPin[1];
antPin[1]=antPin[3];
antPin[3]=swap;
}

Dus strakjes kun je de calibratie en CW CWW gewoon via de terminal instellen
op de software van de Arduino...


Oh wat betreft de snelheid voor het SCF daar moet je een interrupt routine voor gebruiken

https://learn.adafruit.com/multi-taskin ... -interrupt

Dus niet een delay functie

Een timer die na een bapaald aantal clock tikken
een interrupt routine aan roept..

Ongeacht waar de uPC mee bezig is...


Dus net zoals de PWM mode werkt op sommige pinnen van de Arduino...

Ben druk bezig met de bouw van het schema op gaatjes print....

Heb helaas nu niet de Arduino code op stick staan hier...

Kun je zien hoe ik al diverse dingen gefixed heb...

Oh en include MathLab.h is niet nodig..in de IDE van Arduino.

Arduino heeft maar een float type dus niet zoals onder Windows en Visual Studio
een float Single and Double.

Atan2(x,y)

Geeft geen errors bij Atan2(1,0) * Rad1
zoals Atn(x) wel doet...

Division by zero enzo....

Omdat ik ook calibreer heb ik de functie Int LimitDegrees360(int degrees)

Als je een calibratie offset er bij opteld kan het hoger als 360 en lager dan 0 graden worden.

Daar heb ik dus die functie voor.


De functie Average is met multipath detectie
en adjacent kwadrant averaging..

Ik zal de volgende keer weer de source upladen met alle nieuwe snuffies voor in de Arduino.

Oh ik heb ook Arduino 1.63 geinstalleerd die geeft mooi het gebruik aan van RAM

Arduino heeft maar 2048 bytes voor variabelen en 32767 bytes voor programma code.


Dus zuinig zijn met Globale variablen in de Heap en Stack

byte 0-255
int -32768 > 32767

Waar mogelijk gebruik bytes in tellers en arrays hi ipv int / long of float

[pa8w]

Hoi allemaal,

Ik ben inmiddels met uitgebreide veldtests bezig geweest met de Arduino peiler.
Vijf drukknoppen onder het grafisch schermpje:

Werkt inmiddels als een zonnetje:
Geeft dus Azimuth, Elevatie en Quality ( Q ) van de peiling.
Nauwkeurigheid/reproduceerbaarheid van de peiler met testsignalen (zonder antenne): beter dan 2 graden.
Ik heb nu ca. 3 beeld verversingen per seconde, ik denk dat ik dat nog wat verder vertraag om meer rust te creëren.
Menu functies:
Calibratie: Zowel azimuth als elevatie,
Averaging: Bepaalt de stroperigheid van de pelorusbeweging: max 1 graad per verversing bij heel lage Q peilingen.
Een hogere Q peiling wordt zwaarder "gewogen" en kan de pelorusbeweging behoorlijk versnellen.
Dit levert een ruim instelbare, dynamische middeling op, die heel prettig werkt in de praktijk.
Frequency: = rotatiesnelheid, 100 tot 1000Hz in stapjes van 4 Hz instelbaar.
Squelch: Beneden een instelbare peiling Q wordt de pelorus bevroren. 0 = squelch uit, uiteraard.
In de running modus is met een drukknop de ingebouwde speaker in- en uitschakelbaar.
En vanaf de zijkant is de Arduino aansluitbaar voor herprogrammering of voor ontvangst van de Agrelo data.
In de menu modus worden de 4 antennes langzaam doorgestapt en dus getest.

Een 4 polig SCF, een klokdeler en de array-aansturing doe ik met een eigen printje, (waarop de Arduino wordt "geprikt")
Een shield heet dat opeens in Arduino taal ...

De Arduino leest rechtstreeks de 4 C's van het SCF, en doet daar een sin/cos berekening mee etc. etc.
Doordat de Arduino geen timing- gevoelige zaken hoeft af te handelen heb ik dus rekensnelheid genoeg en kan ik willekeurig dingen erbij frutten of weghalen.

Tijdrovend maar leuk speelgoed.

Groetjes,
Wil.

PS Lodewijk: Ik snap even niet waarom je 4 kwadranten separaat wil processen, of C's wil kunnen ledigen...
Kun je me dat (simpel!) uitleggen?

[Dopp]

Hallo Allemaal,

Nieuwe versie SoundDoppler149dAll.zip is op de PI4WAG site

Okay de C's legen is handig om snel te resetten.

Dus geen na echoen van de peiling start met c 'op 1/2U

na bv 10 secondes wil ik starten met schone lei...

Ook average wordt dan geledigd en gevuld met alleen de laatste averaged heading.

In Averaged vind je ook Multipath detect.

Multipath is er als 2 naastliggende kwadranten en de twee andere kwadranten
even veel peilingen hebben.


In Averaged dus bv max 10 secondes samples.
Dan legen en allen de laatste averaged waarde weer terug zetten.
De pijl geeft in mijn sofware dus de directe aan wijzing
en de bug de averaged waarde.

De bug is geel indien er sprake is van multipath ontvangst...
en groen als alles okay is...

Waarom refreshen ?

Omdat je ondertussen gereden hebt en multipath ontvangst gehad misschien
zo na 10 secondes effe de kwadranten in averaged legen.
En vullen met laatse averaged waarde only again
Altijd gemiddelde nemen van twee naast elkaar liggende kwadranten
met meeste peilingen er in.


In SoundDoppler.exe start ik iedere sampleperiod altijd met een leeg SCF filter...

Dat is met 4 c's extern veel lastiger hi....


Misschien is dat ontlaad torretje niet nodig en is gewoon effe
alle 4 de elco's aan massa leggen genoeg om ze allemaal weer even vol te hebben.

Komt er ook nog een averaged bug oid om de pelorus en elevatie boog eh Wil

[PE2AAB]

@PA8W Mooi knutselwerkje!
Op basis van een Uno? Of kan het ook met een Nano?

[pa8w]

@Lodewijk:
Nee, een bug heb ik niet in de planning.
De pelorus zelf kan ik enorm vertragen/middelen.
Je moet onderweg ook niet teveel info op je schermpje krijgen vind ik.

Ik zie eigenlijk het voordeel niet van die "schone lei", maar dat zal wel aan mij liggen.
In principe imiteer ik een heel eind het gedrag van mijn hardware peilers.
Alleen de toegevoegde peiling Quality en de weging daarmee is een extra aanwinst.
Een multipad weging zou ook wat kunnen toevoegen, maar daar wil ik eerst eens wat fundamenteel onderzoek naar doen.
Ook de Quality bepaling is nog open voor discussie.

@AAB:
De Arduino die ik heb gebruikt is een Uno.
Ik gebruik 6 analog inputs,
2 digital outputs,
en verder nog 4 digital outputs voor de beeldschermaansturing.

Eventueel zou je met 4 analog inputs uit kunnen komen.
Ik gebruik een 5e voor de batterijcheck.
En de 6e als toets-scan (via een weerstand-netwerkje), maar daar kan je ook simpelweg 5 digitale inputs voor nemen.

Groetjes,
Wil.

[pa8w]

Ben alweer een stukje verder.
Enerzijds gebruik ik een formuletje voor de amplitudeberekening (Q) waar ik later ook de elevatie mee bepaal.
Tevens suggereert een hoge Q een goede betrouwbaarheid van de peiling en dus accelereer ik de pelorus beweging daarmee bij snelle richtingsveranderingen.

Het nemen van samples doe ik nu dubbel:
De eerste 4 samples (noord oost zuid west) sla ik op.
Dan na een pauze van b.v. 10msec neem ik de 4 controlesamples, en de absolute verschillen met de eerste samples tel ik bij elkaar op in de variabele Diff.
Een lage Diff geeft zo een hoge mate van betrouwbaarheid aan van de sample, en alleen samples met een lage Diff gebruik ik, anders wordt de vorige peiling als "waarheid" gezien en gebruikt.

Ik moet nog even uitwerken wat een goede pauzeduur is tussen samples en controlesamples, en wat een acceptabele waarde voor Diff is, als soort van geloofwaardigheidsdrempel.
Ik overweeg Diff dus ook in het menu op te nemen als instelbare waarde.
In mijn hardware met het 4-polig SCF wordt ruis en modulatie al flink onderdrukt. (de snelle variaties)
De Diff sample beoordeling zal dus denk ik voornamelijk van toegevoegde waarde zijn voor multipad variaties, en dus zal de pauzetijd wellicht iets langer mogen dan 10msec.
Ik ga vandaag een proefritje maken met Diff zichtbaar op het schermpje zodat ik een goede feel voor de grootheden krijg.
Wordt vervolgd!

Groetjes,
Wil.

[pa8w]

Weer een update:
Die controlesamples in mijn opzetje waren zeker geen aanwinst;
Als ik de controle ook maar een klein beetje kritisch zet dan komt er op UHF peilend in de auto geen geldige peiling meer binnen.
Met name binnen de bebouwde kom of tussen bomenrijen heb je zoveel flutter en fladder dat bijna alles wordt afgekeurd.
Gevolg: bevroren pelorus die af en toe een rare sprong maakt als je net weer een goed pakketje binnenkrijgt.
En als je dan de zaak minder kritisch stelt dan vraag je je af wat de toegevoegde waarde is.

Conclusie op dit moment:
Niks later afkeuren of goedkeuren door de computer.
Die computer ziet niet in welke omstandigheden we rijden.
Terwijl een ervaren peiltechneut ook met een zeer slecht signaal de juiste conclusies kan trekken.
Ik krijg het gevoel dat de Arduino me teveel afsluit van de werkelijkheid als ik hem teveel besluiten laat nemen.
Ik heb dus veel meer aan een slimme middeling van ALLE binnenkomende data, al is die nog zo gebrekkig.
In die signalen-brei zit nog heel lang een soort van rode draad die door goede middeling een redelijk betrouwbare peiling oplevert.

Natuurlijk kun je je afvragen of mijn algoritme slim genoeg was, maar ik vrees dat een algoritme nooit slimmer kan zijn dan de schrijver ervan...Hopeloos geval dus.
Alhoewel, ik heb nog een ideetje, moet ik nog even op broeien...

Groetjes,
Wil.

[Dopp]

Hallo Allemaal,

De weer verbeterde code voor de Arduino Sketch

Nu loopt de AntPin controls op een interrupt op timer 0 die op ca 1 KHz loopt

nl 16 MHz / 64

En een plaatje van de Arduino en het shield waar ik mee bezig ben op gaatjes print.

Moet het nog aansluiten op de arduino...

De discharge transistor bc547 zit er nog niet op...

Ik wil het eerst ook zonder proberen nl..



Nog uitzoeken hoe 3 digits via serieel poort binnen komen
om de calibratie te kunnen instellen via de terminal in MyMapping154.exe.

Code: Selecteer alles

/*
  ((C))PA3BNX 
  Trying to create a SuperSimpleArduinoDoppler on Arduino Uno R3
  @12-04-2015
  @13-05-2015
  @15-05-2015
  @17-05-2015
  @22-05-2015
  @24-05-2015
  No Calibration through serialPort yet
  Not ready yet!

  Explaining Arduino pins.
  I did not set the Arduino pins to the shield Yet 
  antPins[] Connect to antenna switcher pins
  refpa3bnx Connect to audio lowpass filter for soundcard referency input 
  kPins[] Connect to kwadrant C's 4u7
  kPins[5] Connect to discharge transistor
  kPinAnalogue Connect to sum point of 4 cap's
 */

//Byte= 0>255
//Int=  -32768>32767

 //String Serial params
 String inputString = "";             //Received serial string 
 
 //Boolean
 boolean bStringComplete = false;     //Complete '\n' rxed serial string  
 boolean bNoSetKpins = false;         //Do not change kPin[] because I am reading/empty them now
 boolean bMultiPath = false;          //Multipath heading found in received headings from Averaged

//Const Integer
//Must be modified to right pin number arduino and arduino shield harddware
//Antenna Control Pins & refpa3bnx
byte antPin[4] = {2,3,4,5};           //Set antenna control pins (Not const because it can CCW/CW) 
const byte refpa3bnx = 6;             //Pin for Referency frequency output to soundcard   

//Kwadrant Capicity switches & analogue SCF read pin
const byte kPin[5] = {7,8,9,10,11};   //4 pins caps 4u7 Last Pin in array = Discharge caps by bc547
const byte kPinAnalog = 0;            //A0 read voltage acros 1 4u7 pin 0 to 5
const int cOffset = 511;              // .5 * 1023 caps offset  

//Squelch Signals
const byte cSqlclosed = 0;
const byte cSqlclosed2open = 1;
const byte cSqlopen2closed = 2;
const byte cSqloverflow = 3;          //Capicitors are full
//

//NoDegreesMaxMinValues
const int cNodegrees = 999;           //Squelch No Signal or cSqlopen2closed
const int cMaxTime = 30;              //15 Sec/cMainLoopDelay Max time
const int cMainLoopDelay = 500;       //How fast the main loop runs in mSec 
const int cMinAudioAmplitude = 100;   //There is enough signal to SinCosDetect

//Float const
const float pi = 4 * atan(1);         //PI 3.14159 
//const float rad = pi/180;
const float rad1 = 180/pi;            //57.295827
//const float TwoPi = 2 * pi;

 
//Integer
//Array with the 4 kwandrant analogue cap tensions These can be -511 to +511 
int Cap[4] = {0,0,0,0};
int Calibrate= 0;                    //degrees default 
byte sqlstatus = cSqlclosed; 


//------------ISR Main Interrupt //This runs always--------------------
SIGNAL(TIMER0_COMPA_vect)
{
 static byte c;
 //Do the Ant and Cap rotation here
 if (c==3){
  c=0;
 }
 SetAntPins(c);
 SetKpins;
 c++; 
}


//---------Functions now-------------------

//Antenna Control Lines Just counts 1234 1234 etc
void SetAntPins(byte t){
static byte tt; 
 //Do never set twice the same pins states
 //Maybe never Needed but it doesn't harm
 if (t != tt){ 
  
 switch (t){
  case 0:
  digitalWrite(antPin[1], HIGH);
  digitalWrite(antPin[4], LOW);
  digitalWrite(refpa3bnx,HIGH);
  break;
case 1:
  digitalWrite(antPin[2], HIGH);
  digitalWrite(antPin[1], LOW);
  break;
 case 2:
  digitalWrite(antPin[3], HIGH);
  digitalWrite(antPin[2], LOW); 
  digitalWrite(refpa3bnx,LOW);
  break;
 case 3:
  digitalWrite(antPin[4], HIGH);
  digitalWrite(antPin[3], LOW);
  break;
}
 tt=t;//Backup tt here
}
}

//Set kwadrant Cap Pins according to antPins
void SetKpins(){
  if (bNoSetKpins==false)
  {
   byte x;
    x != digitalRead(antPin[1]);
   digitalWrite(kPin[1],x); 
   x != digitalRead(antPin[2]);
   digitalWrite(kPin[2],x); 
   x != digitalRead(antPin[3]);
   digitalWrite(kPin[3],x); 
   x != digitalRead(antPin[4]);
  digitalWrite(kPin[4],x); 
 }
}

//Get the 4 analogue value's in Cap[]
void GetCapValues(){
  //All kwadrant Cap Pins HIGH
  for (byte i=0; i<4; i++)
 {
  digitalWrite(kPin[i],HIGH);
 }  
   
  //Read them one by one 
  digitalWrite(kPin[1],LOW); 
  Cap[1]  = analogRead(kPinAnalog)-cOffset;  
  digitalWrite(kPin[1],HIGH);
 
  digitalWrite(kPin[2],LOW);
  Cap[2]  = analogRead(kPinAnalog)-cOffset;  
  digitalWrite(kPin[2],HIGH);
 
  digitalWrite(kPin[3],LOW);
  Cap[3]  = analogRead(kPinAnalog)-cOffset;  
  digitalWrite(kPin[3],HIGH);
 
  digitalWrite(kPin[4],LOW);
  Cap[4] = analogRead(kPinAnalog)-cOffset;  
  digitalWrite(kPin[4],HIGH);
}


//Empty the 4 capicitors by discharging to 1/2 U
void EmptyCaps(){
 for (byte i=0; i<4; i++)
 {
  pinMode(kPin[i],LOW);
 }  
 digitalWrite(kPin[5],HIGH); //Discharge cap pin bc547
 delay(2100); //Let the 4 caps charge to 1/2 U  to 99%  5 * (22k * (4,7uF * 4))  2068 Sec
 digitalWrite(kPin[5],LOW);
}  


//-------------Squelch-----------------------
int Squelch(){
//Return the sqlstatus
//Try Find a full cap   
 int x;
 
 //Find cap with highest voltage/tension
 //Biggest value = cOffset (511)
 for(byte i=0; i<4; i++)
 {
  if abs((Cap[i]) >= cOffset )
  {
   x = abs(Cap[i]);
  }
 }
 
 
 //See if there is a Full Cap 
 //cOffset = Biggest value
 if (x >= cOffset)
 {
  return cSqloverflow;
 //Caps are full so need discharged
 
 }
 else if (x >= cMinAudioAmplitude)
 {
  return cSqlclosed2open;
 }
 else if (x < cMinAudioAmplitude)
 {
  return cSqlclosed;
 }

}

//Calibrate
int Cali(int degrees){
 return LimitDegrees360(degrees(Calibrate + degrees));
}



//Return Agrelo formatted string % and 3 digits always
  char* Format3Degrees(int degrees){
  int digits[3];
  int reminder ;  
  digits[1]=degrees/100;
  reminder = degrees % 100;
  digits[2]= reminder/10;
  reminder = reminder % 10;
  digits[3]=reminder;
  
  char str[4] = {'%','digit[1]','digit[2]','digit[3]'};
  return str;
}

//Limit Degrees 0 to 360 degrees
int LimitDegrees360(int d){
  //Limit degrees 0 to 360 here
  
if (d >= 360){
  return d - 360;
  }
  else if (d < 360)
  {
  return d;
  }
  else if (d < 0)
  {
  return 360 + d;
  }
  else
  {
  return cNodegrees;  
  }
}

//Average
int Average(int d){
  //If d = 999 (cNoDegrees) then reset average
  //Else return averaged degrees
  
  //Integer
  static int sum[4];     //Sum of counts for each kwadrant
  static int c[4];       //Cap tension/voltage in 4 kwadrant
  int xx[4] ={0,0,0,0};  //Adjacent kwadrants
  int z = 0;             //Most adjacent headings
  int z1 = 0;            //Other two kwandants headings 
  int y = 0;             //Index where the most headings are 
  int avDegrees;         //Averaged degrees


 //Limit amount off averaged headings
 if  (c[1]+c[2]+c[3]+c[4] > cMaxTime ){
  for (byte i = 0; i < 4 ; i++){
   sum[i]=0;
   c[i]=0;
  return cNodegrees;
 }
}


  if (d!=cNodegrees){
   
  if (d >= 0 && d < 90){
  sum[1] += d;
  c[1]++;
  } 
  if (d >= 90 && d < 180){
   sum[2] += d;
   c[2]++;
  }
  if (d >= 180 && d < 270){
  sum[3] += d;
  c[3]++;
  }
  if (d >= 270 && d <= 360){
  sum[4] += d;
  c[4]++;
  }
  }
 else
 {
 //Reset
  for (byte i=0; i<4; i++){ 
  sum[i]=0;
  c[i]=0;
  bMultiPath = false;
 }
 return cNodegrees;
}

  //Find 2 adjacent kwadrants with hold most counts
     
  //Count all adjacents kwadrants
  xx[1] = c[1]+c[2];
  xx[2] = c[2]+c[3];
  xx[3] = c[3]+c[4];
  xx[4] = c[4]+c[1];
  
  //Find out in witch two kwadrants the most headings are
  for (byte i=0; i<4; i++){
    if (xx[i] >= z){
    z = xx[i]; //Most Headings
    y = i;     //Witch 2 adjacent Array Index
  }
 }
 

//Check for multipath
switch(z){
case 1:
 z1 = 3;
 break;
case 2:
 z1 = 4;
 break;
case 3:
 z1 = 1; 
 break;
case 4:
 z1 = 2;
 break;
}

if (z > z1){
bMultiPath = true;
}
else
{
bMultiPath = false;
}

  
 //Average the 2 most counts kwadrants
switch(y){
case  1:
 avDegrees = (sum[1] + sum[2]) / c[y];
 break;
case 2:
 avDegrees = (sum[2] + sum[3]) / c[y];
 break;
case 3:
 avDegrees = (sum[3] + sum[4]) / c[y];
 break;
case 4:
 if (c[4] == 0 && c[1] > 0){
 avDegrees = sum[1] / c[1];
 break;
 } 
 if (c[4] > 0 && c[1] == 0){
 avDegrees = sum[4] / c[4];
 break;
 }
 if (c[4] > 0 && c[1] > 0 ){
 avDegrees = LimitDegrees360(((sum[4] / c[4]) + ((sum[1] / c[1]) + 360) / 2));
 break;
 } 
}  
 
if (d == cNodegrees){ 
  return avDegrees;
}
}


//SinCosDetector Find the degrees from the 4 Cap[] tensions
int SinCosDetector(){
  int SinSum; 
  int CosSum; 
  int x;
//In Cap[] is the tension value of 1 of the 4 C'S

SinSum = Cap[1] - Cap[3];  
CosSum = Cap[2] - Cap[4];
  
if (SinSum == 0 && CosSum == 0){
 return cNodegrees;
}
else
{
 return LimitDegrees360(atan2(SinSum,CosSum) * rad1);
} 
}

//=============SerialRx Event=========================== 
void serialEvent() {
  while (Serial.available()) {
    // get the new byte:
    char inChar = (char)Serial.read();
    // add it to the inputString:
    inputString += inChar;
    // if the incoming character is a newline, set a flag
    // so the main loop can do something about it:
    if (inChar == '\n') {
      bStringComplete = true;
    }
     else
     {
     bStringComplete = false;
     } 
  }
}

//===============
  

//------------------------------------Main Functions-----------------------------------------

//SetUp 
void setup() 
{
  // Loop over the pin array and set them all to output:
   Serial.begin(4800); // Opens serial port, sets data rate to 4800 bps
   Serial.println("((C))PA3BNX Arduino Doppler");
   pinMode(refpa3bnx,OUTPUT);
   digitalWrite(refpa3bnx,LOW);
   pinMode( kPinAnalog,INPUT); //Okay here ????
   pinMode(kPin[5],OUTPUT);    //Discharge Pin bc547 
   digitalWrite(kPin[5],LOW);
   for (byte i=0; i<4; i++){
     pinMode(kPin[i],OUTPUT); 
     pinMode(antPin[i] ,OUTPUT);
     digitalWrite(antPin[i],LOW); //antPin LOW 
     digitalWrite(kPin[i],LOW);  //Set Cap pins to low so the can charge to 1/2U
   }
   Average(cNodegrees); //Reset all to 0 
   EmptyCaps;           //All kPins to 1/2 U
 
 
   //Now start ISR interrupt 
   // Timer0 is already used for millis() - we'll just interrupt somewhere
   // in the middle and call the "Compare A" function below
   OCR0A = 0xAF;
   TIMSK0 |= _BV(OCIE0A);
   // ToDo is there a default timer in microseconds to ?
   // Interrupt is called once a millisecond
   // I assume now doppler rotate frequency 4 mSec or 1/.004 = 250 Hz
 }

//Main Loop
void loop() {
  // ToDo
  // GetCapValues
  // Set the ant1,2,3,4 and refpa3bnx  pins ISR
  // Squelch status
  // OverFlow Reset the 4 kwadrant capicitors
  // Calibrate routine (add an degrees offset)
  // SinCosDetector 
  // Send (averaged) and calibrated degrees out through the serialport
  // Receive remote serial cmd's like CW/CCW and Degrees  
  
   //Integer
   byte swap = antPin[1];
   int t;    
    
   bNoSetKpins = true;
   GetCapValues();
   bNoSetKpins = false;
   SetKpins();
    
   sqlstatus = Squelch();      //Squelch status check
     
  if (sqlstatus == cSqloverflow || (t > cMaxTime))
  {
    t = 0; 
    bNoSetKpins = true;
    EmptyCaps(); 
    bNoSetKpins= false;
    SetKpins();  
  } 
 else
 {
  //Relaxed sending degrees to serialport
 if (sqlstatus == cSqlopen2closed && bMultiPath == false)
 { 
   Serial.println(Format3Degrees(Cali(Average(SinCosDetector()))));
   sqlstatus = cSqlclosed;
  }
 }

//Try to read Calibration, CW/CCW, Timing Parameters 
//000<cr> <lf> from MyMapping.exe as calibrate cmd 

serialEvent;                     //Call SerialEvent once in a while

if (bStringComplete == true){
 if (inputString == "CCW"){
   if (swap != antPin[1]){
   swap=antPin[1];
   antPin[1]=antPin[3];
   antPin[3]=swap;
   }
 }
 
 if (inputString == "CW"){
   if (swap != antPin[1]){
   swap=antPin[1];
   antPin[1]=antPin[3];
   antPin[3]=swap;
 }
}
 //How to extract the 3 digits here ? for creating an degrees Int ???
 //ToDo Not done Yet! 

 Calibrate = 0; 
 inputString = "";
} 

delay(cMainLoopDelay);       //Wait 500 mSec for next try ? fast enough I think
t += 1;                     //Total loops to compared against cMaxTime
}


//End of sketch 
 
 

[pa8w]

Hoi Arduinerds,

Hier weer even een update, met excuses voor de beroerde plaatjes.
Ik heb een klein scoopje toegevoegd op het scherm waarmee ik de spanning op de 4 kwadrant-C's kan zien.
Het eerste scherm laat mooi zien hoe een normale situatie er uit ziet: een trapsgewijze "sinus":

Het tweede scherm laat een "vet" multipad signaal zien, waarbij heel goed hoorbaar is dat de dopplertoon verdubbelt:

Je ziet dat zowel de 1e en 3e kwadrant boven de 2e en 4e zitten.
Bij een goed enkel-pad signaal kan dat nooit voorkomen.
Het is verleidelijk om daar een detectie voor e maken.
Nu kan ik voor deze getoonde situatie wel een algoritme bedenken dat een dergelijke uitkomst als fout ziet en eruit knikkert.
Maar multipad signalen genereren nogal wat verschillende variaties en dus ben ik bang dat ik slechts een deel van de troep opruim.
Aan de andere kant ben ik bang dat ik teveel ga opruimen en er te weinig over blijft.

Een massale instroom van frisse ideeën zou hier kunnen helpen dus ik nodig een ieder uit daaraan deel te nemen.

Wordt vervolgd.

Wil.

[Dopp]

Hallo Allemaal,

Het lijkt wel een simpel SCF screen zoals in mijn software hi....

Werk je ook met een offset Wil,

Dus de max 1023 samples - Offset 511

Zodat de waarden + en - zijn ?

Ik doe dat wel in mijn software...

Atan2(SinSum,CosSum) detectie is ongevoelig voor 2e harmonische

Probeer maar is te spelen in SoundDoppler
met de tweede generator op precies 2 x de doppler frequentie met diverse fases
en amplitudes ....

Op jou scherm ziet het eruit alsof de lage signalen niet onder de nul lijn komen.
van het tweede scherm.

Okay het zijn maar 4 kwadranten samples
en geen 120 oid of meer zoals met de geluidskaart in SoundDoppler

Dus Edit demo2 en dan knop Adjust drukken...
in XYscoop formulier.

Waarom de Q:8 apart in pelorus printen en niet als
144/8 oid ?

Nog wat arduino dingetjes:

PI zit gewoon in de standaard libs net als TWO_PI

Ik deed voor pi eerst gewoon 4 * atan(1)

[pa8w]

Ok, een flinke stap verder in het detecteren en uitschakelen van corrupte peilingen door multi-pad vervormingen:
In mijn opzetje zijn mijn kwadrant-C's in rust geladen met ca. 5V , dat geeft 510 op een analoge input van de Arduino.

Na het samplen van de 4 kwadranten C's bereken ik het gemiddelde van die 4, dat is ook normaliter 510, omdat de input van mijn hardware AC gekoppeld is.
Dan kijk ik of zowel C1 als C3 beiden boven of beide onder dat gemiddelde zitten,
en daarna of zowel C2 en C4 beide boven of beide onder dat gemiddelde zitten.
Zo ja, is de sample zeker corrupt, en negeer ik deze, en signaleer dat met FREEZE op het scherm.

Als ik nu peilend rondrijd (met de squelch uit) in een reflectie-rijke omgeving dan zie ik heel vaak kortstondig FREEZE opduiken als teken dat foute info wordt genegeerd.
Er blijven nog meer dan genoeg goede pakketjes over om een fatsoenlijke peiling te handhaven.
Ik geloof dat dit een heel bruikbaar filter is, maar ik moet morgen nog een veldtest doen met signalen net boven ruisniveau.
Desnoods maak ik deze feature aan/uit schakelbaar.

Ik geloof dat ik met dit betoog gelijk antwoord heb gegeven op een paar van je vragen Lodewijk.

Groetjes,
Wil.

[pa8w]

Herstel;
C's zijn geladen met ca. 2,5 V =510 op de Arduino...
Wil.

[Goos]

Ja inderdaad Wil, lijkt me een goeie , geeft de veranderingen veel scherper aan voor zover ik het hier even kan simuleren dan mijn oplossing met de amplitude veranderingen.
Ik heb vroeger een paar ritten gemaakt met verschillende antennes waarvan ik de samples opgeslagen heb. zodra ik weer op het werk ben ga ik er daar eens mee aan de gang om dit er op los te laten. ( lekker een maandje vakantie )

De veranderingen vd AM werkte bij mij ook wel goed , inderdaad er vielen er een hoop af, maar ik had natuurlijk geen average van een scf

Ben benieuwd naar de uiteindelijke resultaten.
Met de Arduino die jij gebruikt heb je geloof ik geen mogelijkheid om alles realtime op te slaan ?

gr
Goos