arduino frekwentie / 8

ik ben een frequentie uitlezing aan het bouwen met nixie buisjes. Het rekenwerk zal gebeuren met een arduino UNO. Om zeker te zijn dat de arduino een signaal kan inlezen heb ik eens een testopstelling gemaakt. Een oscillatorblokje van 1MHz sluit ik aan op een analoge ingang.(zo een metalen doosje werkende op 5V) Op een digitale uitgang laat ik verschijnen het signaal gedeeld door 8. Het programma is geschreven door BING AI. Als ik meet met de scoop dan zie ik op de ingang een signaal van 1µs (1MHz) en op de uitgang 32µs (31,25 kHz). Ik verwacht als ik een 1 MHz signaal deel door 8 een signaal van 125 kHz. Enig idee wat hier aan de hand is ?
Hierna het arduino programma.


// Pin definitiesconst 
int inputPin = A5;
// Ingang voor het 1 MHz signaalconst 
int outputPin = 3;
// Uitgang voor het gedeelde signaal

void setup()
 {  
pinMode(inputPin, INPUT);
// Stel A5 in als ingang  
pinMode(outputPin, OUTPUT);
// Stel D3 in als uitgang
}
void loop()
 {  
// Lees het 1 MHz signaal van A5  
int inputFrequency = pulseIn(inputPin, HIGH);
// Deel de frequentie door 8  
int outputFrequency = inputFrequency / 8;
// Genereer het gedeelde signaal op D3  
tone(outputPin, outputFrequency);
}

Alvast dank,
Marc

[Bericht gewijzigd door Henry S. op (1%)]

Kan die ingang wel een sample doen van 1 mHz ?
Hoe groot een getal kan maximaal in een variabele van het type Int ?

Ik verwacht dat er een hoop pulsen worden overgeslagen omdat 1MHz veel te snel is...

Nog een hint : pulsein commando geeft geen frequentie als antwoord maar iets anders..

The timing of this function has been determined empirically and will probably show errors in longer pulses. Works on pulses from 10 microseconds to 3 minutes in length.

Ik zal een ander programma moeten gebruiken. 1 MHz is 1µs per periode. Dus veel te snel. Hierbij is nogmaals bewezen dat AI ook foutjes maakt. Ik vind het nog altijd wonderbaar dat een AI zoals bing in een fractie van een seconde een sketch kan fabriceren.

Met aftrek van de inherente traagheid van intikken kan ik meer onzin bedenken op minder tijd.
Leer zelf programmeren, dan leer je nog wat!

Voor uw idee is er dus een prescaler nodig, dat kan een simpele cd4060 zijn of zo, of ook iets dat vanuit de cpu kan ingesteld worden - soepeler maar complexer en duurder.

@Arco hieronder: : (handshake) + : (broad_smile)

Op zaterdag 6 april 2024 19:53:09 schreef VORENUS:
Ik zal een ander programma moeten gebruiken. 1 MHz is 1µs per periode. Dus veel te snel.

Nee, een controller gebruiken die wat rapper is... ;)

Het kan makkelijk met een Arduino Uno, een ingangssignaal van maximaal 1MHz door 8 delen.

Maar je moet wel wat meer moeite doen: Een time met externe klok gebruiken, of een pin-change interrupt op de ingang zetten en zorgen dat die in 12 cpu klokken klaar is (AVR heeft sowieso 4 klokken nodig om in een interrupt te komen)

Dat laatste is met standaard Arduino code alvast onmogelijk, want die gebruikt onder water de GCC-AVR compiler, en die poept voor een interrupt-routine al meer dan 12 instructies overhead uit.

Een tight loop (van minder dan 16 klokken) waarin je de verandering van de pin kunt waarnemen en zo de flanken kunt tellen kan ook werken. Misschien zelfs in C (Arduino) code, alhoewel je eigenlijk naar de gegenereerde machinecode moet kijken of de compiler iets bruikbaars gemaakt heeft..

Je chip heeft een hardware timer die ook kan capturen, daarmee kun je best frequentie meten.

Maar je hoeft een frequentie niet te meten om 'm door 8 te delen. Alleen tot 8 te tellen op de te delen frequentie en elke keer JA te roepen als je bij 8 bent.


uint8_t i=0;
while(1){
 if(PORTA&(1<<PORTA5) i++; // haha, wat gebeurt hiermee als porta 5 constant hoog is? Juistem, dat gaat nevernooitniet goed werken, je moet flanken tellen
 if(i>=7){
  PIND=(1<<PIND3); // toggle PORTD.3
  i=0;
 }
}

Dus, iets beter:


//interrupt handler voor pin change interrupt die ingesteld is
  om alleen op opgaande flank te triggeren (of neergaande, maar in
 elk geval 1 flank) 
{
 i++;
 if(i>6){   
  PIND=(1<<PIND3)
  i=0;
 }
}

En als je het slechter leesbaar wilt, kun je iets met:
PIND=(((i>>3)&(0x01))<<PIND3). Dan hoef je i niet meer op 0 te zetten.

{EDIT: je haalt alsnog de MHz niet hiermee, door de interrupt-overhead, zie blurp hierboven. Wat SparkyGSX verderop doet is veel sneller}

Waarom eigenlijk op een analoge ingang?

Een frequentie door 8 delen doe je trouwens makkelijker in hardware, maargoed. (4017,4018,4020, weet ik veel, kies een leuke counter)

Een Atmege16 kan direct tot 70Mhz tellen
http://www.herbert-dingfelder.de/?page_id=304

Ik zou dan verwachten dan de ATmega328P op een arduino uno dat ook moet kunnen.
Volgens deze website moet 6 Mhz in de arduino en zijn software haalbaar zijn.
https://projecthub.arduino.cc/moty/frequency-counter-b0aca3
Als je meer dan 6 Mhz wil tellen dan heb je een externe deler chip nodig

Ik weet inderdaad dat het stukken eenvoudiger is een deler te maken met bvb. een HC4040. Maar de bedoeling was enkel om na te gaan of de pulsen van het 1 Mc oscillatorblokje door de arduino kunnen worden ingelezen.
Ik ben van plan om de nixie display van "Glasslinger op youtube na te bouwen. ( https://www.youtube.com/watch?v=mvCwzLowmOo&t=1976s )
Om de schakeling en het programma te testen zal ik geen ontvanger gebruiken maar een frekwentiegenerator. Die Glasslinger kan ik trouwens niet contacteren. En dat is jammer gezien er foutjes zitten in het schema en alsook in zijn sketch.
Intussen heb ik kunnen testen of een 1 Mc signaal kan worden gemeten.
Ik heb volgende sketch gebruikt : ( https://www.onetransistor.eu/2018/09/how-to-count-frequency-with-ardui… )

Met een hardware timer is duidelijk technisch de beste oplossing, maar ik zat even te denken wat er in een domme loop haalbaar zou zijn.


#define INPORT PORTA
#define OUTPORT PORTB
#define INMASK 0x01
#define OUTMASK 0x02

while(1){
  while( INPORT & INMASK );
  while( ~INPORT & INMASK );
  while( INPORT & INMASK );
  while( ~INPORT & INMASK );
  while( INPORT & INMASK );
  while( ~INPORT & INMASK );
  OUTPORT |= OUTMASK;
  while( INPORT & INMASK );
  while( ~INPORT & INMASK );
  while( INPORT & INMASK );
  while( ~INPORT & INMASK );
  while( INPORT & INMASK );
  while( ~INPORT & INMASK );
  while( INPORT & INMASK );
  while( ~INPORT & INMASK );
  OUTPORT &= ~OUTMASK;
  while( INPORT & INMASK );
  while( ~INPORT & INMASK );
}

Ik denk dat je hiermee wel tot 1MHz komt, maar niet veel verder. Als je INPORT helemaal kunt gebruiken, met alle andere ingangen laag, en OUTPORT helemaal mag overschrijven (die kunnen dan dus ook niet dezelfde poort zijn) kun je de bit operaties achterwege laten, en hoeft OUTPORT ook niet gelezen te worden voor de verandering.

Je krijgt dan dit:


#define INPORT PORTA
#define OUTPORT PORTB

while(1){
  while( INPORT );
  while( !INPORT );
  while( INPORT );
  while( !INPORT );
  while( INPORT );
  while( !INPORT );
  OUTPORT = 0xFF;
  while( INPORT );
  while( !INPORT );
  while( INPORT );
  while( !INPORT );
  while( INPORT );
  while( !INPORT );
  while( INPORT );
  while( !INPORT );
  OUTPORT = 0;
  while( INPORT );
  while( !INPORT );
}

Ik denk dat een logische inverse sneller is dan een bitwise, want die bitwise is een aparte instructie, terwijl de logische een jump zero of jump not zero wordt, en dat duurt dus even lang.

EDIT: ik bedenk net dat je de inverse in de eerste code ook logisch kunt doen in plaats van bitwise, maar misschien is de compiler al slim genoeg om dat te genereren?

Het nadeel hiervan is natuurlijk dat de controller niets anders meer kan doen, het voordeel is dat de deling wel exact klopt, ook als de interval tussen de pulsen niet helemaal constant is. Je zou hiermee ook kunnen delen door een deler die geen integer is, doe de loop de kopiëren en de tweede één puls korter of langer te maken. De interval van het uitgaande signaal wisselt daarmee ook, maar het aantal pulsen klopt.