Hoe kan ik een geschutstoren 290 graden laten draaien

Alle lijnen voor ch2 verwijderd;
delay(100) geeft 2 kanaalwaarden en 1 synchronisatiepuls (zoals Corrien dat noemt)
delay() geeft een foutmelding: too few arguments to function 'void delay(long unsigned int)'
delay(0) geeft 8 kanaalwaarden en 1 synchronisatiepuls
delay helemaal verwijderd geeft zelfde als delay(0)
het kantelmoment tussen 2 of 8 waarden weergeven ligt nu tussen 98 en 99ms delay

voor Max

 

Dit is wat je zoekt toch? Dus delay er uit halen...

Ik ben bezig iets te bedenken waarmee je de kanaalwaarden direct naar verschillende servo's kan doorzetten, maar het wil nog niet lukken. Morgen misschien....

 

als het werkt zonder, dan mag het na de testfase er uit, maar ik kan zo rap de serial monitor niet lezen

 

Multiprop decoder.

Ik heb geen Multiprop module, dus testen gaat wat moeizaam.
Kanaal 8 aansluiten op poort 4.
Als het goed is worden de 8 sub-pulsen direct verspreid naar de bijbehorende servo's op poorten 5 t/m 12.

Hier de code:

Code:

int subcount, pulse;
bool start = false;

#include <Servo.h>
Servo MPS[8]; // array of Multi Prop Servo objects

void setup() {
 
  pinMode(4, INPUT);
 
  Serial.begin(9600);

  for (int i=0; i<8; i++) {
  MPS[i].attach (i+5); // servo output attached to pins 5 - 12
  }
}

void loop() {
 
  pulse = pulseIn(4, HIGH); // timeout?

  if (start && pulse <= 1950) {
    MPS[subcount-1].writeMicroseconds(pulse); // array starts at MPS[0], ends at MPS[7]
    Serial.print ("MPS"); Serial.print (subcount); Serial.print (" "); Serial.print (pulse); Serial.print ("   ");
    subcount += 1; 
    if (subcount >8) {
      start = false; // stop saving subchannels after 8 counts
      delay(500); // only for testing the output by monitor, deactivate for servo operation
    }
  }
 
  if (pulse >= 2000) { // syncpulse
    start = true;
    subcount = 1;
    Serial.println ("");
  }
}

De pulsen zijn een beetje wiebelig, dat is inherent aan het gebruik van de Servo_h library en/of het gebruik van pulseIn() om het Rx-kanaal uit te lezen.

 

@Ecstacy
Die eerste link ziet er verbluffend uit, precies wat ik zoek, merk zender komt nog overeen ook, maar hij gebruikt geen Uno, en ik raak er niet aan uit om de poortnummers aan te passen zodat het op een Uno past
Die 2e link (Duitse site dan maar geprobeerd:
met de eerste code inderdaad vastgesteld dat ik 9 waarden uitlees, maar mijn synchronisatiepuls is hoog (2100) en de andere waarden gaan van 940 tot 2100.
De 2e code

#define schalter 8 //Anzahl der Schalter bzw. Impulse
int value[schalter];
void setup()
{
pinMode(3, INPUT); //Pin 3 als input
pinMode(4, OUTPUT);
}
void loop()
{
while(pulseIn(3, HIGH) > 1000){} //Wait for the beginning of the frame
for(int x=0; x<=schalter-1; x++)//Loop to store all the channel position
{
value[x]=pulseIn(3, HIGH);
}
if ((value[0] < 1100) && (value[0] > 1000)) {
digitalWrite(4, HIGH);
} else {
digitalWrite(4, LOW);
}
}

dus een beetje getweakt tot dit

#define schalter 8 //Anzahl der Schalter bzw. Impulse
int value[schalter];
int j=7; // door j te veranderen van 0 tot 7 kan je kijken bij welke potmeter de LED aan en uitgaat
void setup()
{
pinMode(3, INPUT); //Pin 3 als input
pinMode(13, OUTPUT);
}
void loop()
{
while(pulseIn(3, HIGH) < 2095){} //Wait for the beginning of the frame
for(int x=0; x<=schalter-1; x++)//Loop to store all the channel position
{
value[x]=pulseIn(3, HIGH);
}

if ((value[j] < 2050) && (value[j] > 980)) {
digitalWrite(13, HIGH);
} else {
digitalWrite(13, LOW);
}

De toegevoegde of aangepaste code heb ik in het rood aangeduid.
Een eerste succes geboekt dus

Nu even laten bezinken, want ik ga daar zodanig in op dat ik er slapeloze nachten van heb

 

Ja, dat zal zo wel kunnen werken. Deze code werkt alleen voor schakelaars, voor proportionele servo's zul je hem moeten aanpassen, bijvoorbeeld met de Servo_h library die ik gebruikt heb.

Je hebt terecht de while loop aangepast naar <2095, zo blijft de code "hangen" totdat er een langere puls voorbijkomt en een synchrone start oplevert. Hoe dat in de oorspronkelijke code zou moeten werken weet ik niet, tenzij daar een synchronisatie puls met een lengte <1000 gebruikt wordt.

Ik zie alleen niet in waarom je alle waarden moet opslaan in een array, en ze dan later weer uitlezen.
In de code die ik plaatste wordt de binnengehaalde waarde onmiddellijk naar de bijbehorende servo gestuurd, al dan niet eerst bewerkt. Daarna start de loop opnieuw, haalt een nieuwe waarde binnen, enz. met de volgende puls.

 

Ik herken dat wel, daarom ben ik blij dat ik mijn laatste code hierboven gisteravond nog werkend gekregen heb

 

Hier gaat toch de Led op elk (sub)kanaal bij elke potmeterstand aan? Niet wat je wilt denk ik.

 

In de post van Corrien die je citeerde, wordt daarnaar verwezen, als ik REVerse instel in de zender ga ik waarschijnlijk een lage puls als synchronisatiepuls krijgen.

Dat was maar om alle kanalen te testen, 1 voor 1, door telkens de variabele j te wijzigen en ik niet telkens op 2 plaatsen het kanaalnummer moet aanpassen.

Inmiddels heb ik met succes een vervolgtest gedaan, met 8 LED's tegelijk, op pins 4 tot en met 11 aangesloten.

Ook dit is niet wat ik uiteindelijk wil, maar door babystapjes voorwaarts te zetten, hoop ik inzicht te verwerven, en niet te vaak hopeloos op mijn tronie te vallen

Volgende test wordt een LED vervangen door een servo en deze op de maat van de pot laten bewegen.
Ik hou jullie op de hoogte van het resultaat, maar kan al verklappen dat er een addertje onder het gras zit, dat ik ook al op 't internet gelezen heb, namelijk dat het actieve bereik van de potmeters eerder beperkt is, en dat bij het grootste deel van de uitzwaai de uitgelezen waarde niet meer verandert.
Ik probeer dit in een volgende bijdrage visueel te illustreren.

 

Ik bedoelde dat de if-voorwaarde was dat de pulslengte tussen 980 en2050 moest liggen om de led te ontsteken, dat is toch altijd waar? Tenzij je met een potmeter buiten dat bereik kan komen...

 

uitgelezen potwaarden gaan van 940 tot 2100, waardoor ik moet oppassen dat geen enkele pot de waarde van de synchronisatiepuls nadert als ik de Arduino opstart.
Dus als ik de pots verdraai buiten die waarden, gaat hij uit.
Ik zou een leuk filmpje kunnen maken ervan, maar ik kan geen video bewerken, en mijn gestuntel wil echt niemand zien

 

Ik heb vandaag mijn Multiprop decoder sketch ( post #64) nog verder getest door een servo op diverse outputs er aan te hangen. Het probleem daarbij is dat ik natuurlijk niet de juiste input heb, omdat ik geen multiprop heb. Ik hang er dus maar een gewone servotester aan, die ik eerst helemaal open moet draaien om een synchronisatiepuls te creëren, en vervolgens weer terug moet draaien om één reeks van 8 pulsen te genereren, maar die dus theoretisch allemaal hetzelfde zijn. Maar als je 'm met een flinke zwiep terugdraait krijg je toch een in lengte aflopende reeks pulsen in de monitor te zien vanwege het tijdsverschil van opname. Een servo aansluiten op één van de uitgangen levert een verklaarbaar gedrag op, dus de conclusie is: het werkt|

 

De sketch in post #64 is aangepast met een tijdelijke delay() om een leesbaar resultaat in de monitor te verkrijgen.

 

Ik begrijp dit niet, de Multiprop zal toch wel zó ontworpen zijn dat je met de pots de synchronisatie puls niet kan overschrijden?

 

De sketch in post #64 nogmaals aangepast, fout in de servo-pintoewijzing. Een array met 8 plaatsen begint met [0] en eindigt met [7], even in dat stuk code over het hoofd gezien......

 

overschrijden niet, maar wel benaderen of gelijk aan. alle waarden fluctueren constant met enkele milliseconden, en de maximumwaarden van de pots liggen wel heel dicht bij die van de synchronisatiepuls.

 

Als je dat baseert op wat je in de monitor uitleest, komt dat (mede?) ook door de timer in de chip, die heeft last van periodieke oprispingen......
Overigens hoop ik wel dat het microseconden zijn..

 

Hallo @max z ,
Ik heb net je code uitvoerig live getest.
Ondanks onze wederzijdse inspanningen word ik er niet happy van.
De uitgelezen kanaalwaarden zijn soms enkele "microseconden" hoger of lager dan de synchronisatiepuls, en dan slaat de boel op hol.
Blijf ik binnen de grenswaarden met alle pots, en dat is met een verdraaiing van niet meer dan een graad of 20 in elke richting, dan beweegt de aangestuurde servo.
Die beweging is echter veel te snel en schokkerig.

Ik vraag me af of ik niet beter overstap naar steppermotors (met 2 eindswitches om de reisweg tijdig te stoppen).
bij een kleine verdraaiing naar links kan de geschutstoren dan naar links draaien, terug in het midden is stoppen, en de pot naar rechts draaien geeft een beweging van de steppermotor naar rechts.
De snelheid kan ik aanpassen, en vermits die gering is kan ik tijdig de pot terugdraaien om te stoppen of de andere richting uit te draaien.
De eindswitches zorgen er dan voor dat de lopen de opbouw niet rammen.

 

Tsja, ik gaf al aan dat ik e.e.a. niet goed kan testen omdat ik geen multiprop unit heb. Het enige wat ik kan doen is met de servotester eerst een syncpuls genereren, daarna een servo aansluiten op pin 12 / subkanaal 8, en dan de tester voorzichtig terugdraaien totdat er een serie pulswaarden gegenereerd wordt. Op dit kanaal resulteert dat in een maximum pulswaarde van rond 1900 micros.
Vervolgens maak ik weer een syncpuls, maar daarna draai ik de tester zo snel mogelijk helemaal terug. Dat genereert dan op subkanaal 8 een aanzienlijk lagere pulswaarde, waar dan de servo zonder schokken of haperen naar toe snelt.

Te snel kan verholpen worden, maar daar is extra code voor nodig. Ben ik mee bezig.
Ik kan 2 oorzaken voor het schokken bedenken:
- het seriële verkeer met de monitor neemt nogal wat tijd in beslag, misschien dat dat tot schokkerig gedrag leidt.
- je hebt teveel servo's aan de Uno aangesloten, inclusief de voeding. Dat kan de spanningsregelaar dan niet verwerken, en de servo's gaan schokken en elkaar beïnvloeden.

Het is mogelijk om met een constrain() de pulswaarde tot dit bereik te beperken. Heb je enig idee wat de pulswaarde van de syncpuls is?

Edit: dit wordt toch moeilijk, je wilt namelijk dat de syncpuls als zodanig herkend wordt, en daarom kun je de pulswaarde niet beperken.

 

Overigens is een bereik van 940 tot 2100 ruim voldoende om bij een servo een beweging van minstens 50 graden naar elke richting te bewerken, en de code zal dat niet veranderen. Dus waar die beperkte beweging van 20 graden vandaan komt..........