Akustiska måltavlor

[kattafan]

Blir lite trött.

Satte variablerna till volatile enligt tidigare diskussion och då gick det att stänga av studsen enkelt och snabbt. Men...Interrupten aktiveras ju likförbannat och den första mikrofonen stör väl ut den andra mikrofonens interrupt på nån vänster. Eller så är min diskbänk betydligt större än jag trott, närmare bestämt 17m!

Sen provade jag en annan grej och då fick jag svarstider på 16us, vilket motsvarar ett avstånd på ca 6mm. Inte coolt.

Till sist provade jag att vålda av interrupten i samband med att de triggades. Det gav faktiskt hyfsade värden. Jag har mikrofonerna 50cm från varandra och jag klappar bortanför den ena så att tiden mellan mikrofonerna alltid ska vara samma. Första mätserien gav ett snitt på 58cm med 12cm standrardavvikelse och andra serien gav 81cm med en standardavvikelse på 27cm. Fubar m a o.

Idéer?


Den senaste iterationen av koden:

Kod: Markera allt

const byte interruptPin1=2;
const byte interruptPin2=3;

volatile long mictime1=0;
volatile long mictime2=0;
volatile bool bounce1=false;
volatile bool bounce2=false;
volatile long time_now;

void setup() {

Serial.begin(115200);

//starta interrupten
  pinMode(interruptPin1, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(interruptPin1), blink1, CHANGE);
  pinMode(interruptPin2, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(interruptPin2), blink2, CHANGE);

}

void loop() {


noInterrupts();
Serial.print("Mic1: ");
Serial.print(mictime1);
Serial.print(", Mic2: ");
Serial.println(mictime2);
Serial.print(", Diff: ");
Serial.println(mictime2-mictime1);


mictime1=0;
mictime2=0;
bounce1=true;
bounce2=true;

interrupts();

//koppla på interrupten
//starta interrupten
  pinMode(interruptPin1, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(interruptPin1), blink1, CHANGE);
  pinMode(interruptPin2, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(interruptPin2), blink2, CHANGE);

 time_now = millis();

    while(millis() < time_now + 1000){}
        //wait approx. 1000 ms

 }

 void blink1(){
   if (bounce1=true) {
    
     mictime1=micros(); 
     bounce1=false;
     detachInterrupt(digitalPinToInterrupt(2));
     
   }
 }


 void blink2(){
   if (bounce2=true) {
     mictime2=micros(); 
     bounce2=false;
     detachInterrupt(digitalPinToInterrupt(3));
     
   }
 }
 

[Fält]

Blir lite trött.

Satte variablerna till volatile enligt tidigare diskussion och då gick det att stänga av studsen enkelt och snabbt. Men...Interrupten aktiveras ju likförbannat och den första mikrofonen stör väl ut den andra mikrofonens interrupt på nån vänster. Eller så är min diskbänk betydligt större än jag trott, närmare bestämt 17m!

Sen provade jag en annan grej och då fick jag svarstider på 16us, vilket motsvarar ett avstånd på ca 6mm. Inte coolt.

Till sist provade jag att vålda av interrupten i samband med att de triggades. Det gav faktiskt hyfsade värden. Jag har mikrofonerna 50cm från varandra och jag klappar bortanför den ena så att tiden mellan mikrofonerna alltid ska vara samma. Första mätserien gav ett snitt på 58cm med 12cm standrardavvikelse och andra serien gav 81cm med en standardavvikelse på 27cm. Fubar m a o.

Idéer?

Kod: Markera allt

void loop() {


noInterrupts();
Serial.print("Mic1: ");
Serial.print(mictime1);
Serial.print(", Mic2: ");
Serial.println(mictime2);
Serial.print(", Diff: ");
Serial.println(mictime2-mictime1);


mictime1=0;
mictime2=0;
bounce1=true;
bounce2=true;

interrupts();

 

Om jag inte missat något så är dina interrupter avstängda nästan hela tiden. Presentationen tar mycket lång tid jämfört med resten av programmet.

Om du instället kontrollerar om mictime1 och mictime2 har ändrats från noll innan du presenterar resultatet så är du nog i bättre form.

Så något i stil med:

Kod: Markera allt

if (mictime1 && mictime2)
{
// Presentera resultat 
}

[lasse-a]

Blir lite trött.

Satte variablerna till volatile enligt tidigare diskussion och då gick det att stänga av studsen enkelt och snabbt. Men...Interrupten aktiveras ju likförbannat och den första mikrofonen stör väl ut den andra mikrofonens interrupt på nån vänster. Eller så är min diskbänk betydligt större än jag trott, närmare bestämt 17m!

Sen provade jag en annan grej och då fick jag svarstider på 16us, vilket motsvarar ett avstånd på ca 6mm. Inte coolt.

Till sist provade jag att vålda av interrupten i samband med att de triggades. Det gav faktiskt hyfsade värden. Jag har mikrofonerna 50cm från varandra och jag klappar bortanför den ena så att tiden mellan mikrofonerna alltid ska vara samma. Första mätserien gav ett snitt på 58cm med 12cm standrardavvikelse och andra serien gav 81cm med en standardavvikelse på 27cm. Fubar m a o.

Idéer?


Den senaste iterationen av koden:

Kod: Markera allt

const byte interruptPin1=2;
const byte interruptPin2=3;

volatile long mictime1=0;
volatile long mictime2=0;
volatile bool bounce1=false;
volatile bool bounce2=false;
volatile long time_now;

void setup() {

Serial.begin(115200);

//starta interrupten
  pinMode(interruptPin1, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(interruptPin1), blink1, CHANGE);
  pinMode(interruptPin2, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(interruptPin2), blink2, CHANGE);

}

void loop() {


noInterrupts();
Serial.print("Mic1: ");
Serial.print(mictime1);
Serial.print(", Mic2: ");
Serial.println(mictime2);
Serial.print(", Diff: ");
Serial.println(mictime2-mictime1);


mictime1=0;
mictime2=0;
bounce1=true;
bounce2=true;

interrupts();

//koppla på interrupten
//starta interrupten
  pinMode(interruptPin1, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(interruptPin1), blink1, CHANGE);
  pinMode(interruptPin2, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(interruptPin2), blink2, CHANGE);

 time_now = millis();

    while(millis() < time_now + 1000){}
        //wait approx. 1000 ms

 }

 void blink1(){
   if (bounce1=true) {
    
     mictime1=micros(); 
     bounce1=false;
     detachInterrupt(digitalPinToInterrupt(2));
     
   }
 }


 void blink2(){
   if (bounce2=true) {
     mictime2=micros(); 
     bounce2=false;
     detachInterrupt(digitalPinToInterrupt(3));
     
   }
 }
 

Jag sitter inte i "labbet" så jag kan inte koppla upp en funktionsgenerator och se hur det blir, men en del frågor uppstår:

Du sätter dina interrupts som "change". Vad är tanken med det? Med "change" så kommer de att slå två gånger för en signal som går först hög, sedan låg. Varför inte exv. "falling" (eftersom du har INPUT_PULLUP)?

Sedan så har du deklarerat dina variabler som "long", då blir de med tecken, vilket kan ställa till det med räknare (ja det kan iofs krångla även när de "bläddrar över" till noll igen). Med 32-bitars signerade tal så kommer de att bli negativa när datorn kört i drygt 35 minuter om jag räknat rätt. Så jag skulle deklarerat dem som "unsigned long" så undviker du iaf det problemet.

Sedan så förstår jag inte hur du tänkt i din huvudloop? Tanken där är ju att vänta tills du fått båda interrupten och först då räkna ut skillnaden. Alltså något i stil med:

Först så sätter du bounce1 & 2 till true. Sedan en while-loop:

Kod: Markera allt

while(bounce1 == false && bounce2 == false) ; // Wait for triggers

(Ja, ja, C-nörd hade skrivit det:

Kod: Markera allt

while(!bounce1&&!bounce2) ; 

, nej förresten, en C-nörd hade skrivit det

Kod: Markera allt

while(!(bounce1&bounce2)) ; 

)

Sedan så gör du dina beräkningar, väntar för att avstudsa (delay(1000) är ett enkelt sätt), sätter

Kod: Markera allt

bounce1 = bounce2 = true; 

och så är det klart att köra igen.

Jag har inte provat ovanstående, så jag garanterar inte att det är bugg-fritt...

[kattafan]

huj, det var mycket. Testar senare.
Det är ingen tanke med nåt, jag bara klipper och klistrar hej vilt. Tänk oändligt med chimpanser med skrivmaskiner kommer för eller senare att skriva ihop ett av Shakespears mästerverk.

Tack!

[Fält]

huj, det var mycket. Testar senare.
Det är ingen tanke med nåt, jag bara klipper och klistrar hej vilt. Tänk oändligt med chimpanser med skrivmaskiner kommer för eller senare att skriva ihop ett av Shakespears mästerverk.

Jag behöver också en hel del tur när jag skriver kod. Men då jag hjälpte de som kan koda, med att läsa datablad för ATMega och fundera ut hur de olika funktionerna användes på ett stort projekt så hade jag en gång ganska god insikt i den inbyggda kringutrustningen i ATMega. Det gör det lite lättare att ha tur.

En Arduino Micro med ATMega 32u4 är framletad!

[lasse-a]

Jag behöver också en hel del tur när jag skriver kod. Men då jag hjälpte de som kan koda, med att läsa datablad för ATMega och fundera ut hur de olika funktionerna användes på ett stort projekt så hade jag en gång ganska god insikt i den inbyggda kringutrustningen i ATMega. Det gör det lite lättare att ha tur.

Så är det ju. Ju mer man övar, desto mer tur får man!

[detstorabla]

Hittade detta...

https://www.kjell.com/se/produkter/el-v ... ort-p87072

Det löser med all sannolikhet de bitar som är tidskritiska. Håller på med verilogkoden för fpgan. Återkommer med simuleringsresultat för den digitala biten. Beräkningarna görs förstås i cpu


Skickat från min iPhone med Tapatalk

[lasse-a]

Hittade detta...

https://www.kjell.com/se/produkter/el-v ... ort-p87072

Ja, det är ju ett snäpp upp. Men kostnaden följer förstås med. (Kretsar i lägre prisklasserna finns, men inte mycket färdiga kort. De blir snabbt svindyra.)

Det löser med all sannolikhet de bitar som är tidskritiska. Håller på med verilogkoden för fpgan. Återkommer med simuleringsresultat för den digitala biten. Beräkningarna görs förstås i cpu

Fegis! Har man en FPGA så får man ju i så fall åtminstone implementera en enkel CPU på den som kör beräkningskoden. Så sånt fusk det tolererar vi inte.

[detstorabla]

Kortet har redan en processor som kan kommunicera med fpgan. 900 spänn är ju en rätt billig lösning....

Allt förutsatt att fpgan räcker till...


Skickat från min iPhone med Tapatalk

[Fält]

Hittade detta...

https://www.kjell.com/se/produkter/el-v ... ort-p87072

Det löser med all sannolikhet de bitar som är tidskritiska. Håller på med verilogkoden för fpgan. Återkommer med simuleringsresultat för den digitala biten. Beräkningarna görs förstås i cpu

Det går kanske att porta till en billigare FPGA i framtiden? Jag har inte ens viljat tänka på FPGA även om jag vet att det är den bästa lösningen.

[lone_wolf]

Hittade detta...

https://www.kjell.com/se/produkter/el-v ... ort-p87072

Det löser med all sannolikhet de bitar som är tidskritiska. Håller på med verilogkoden för fpgan. Återkommer med simuleringsresultat för den digitala biten. Beräkningarna görs förstås i cpu


Skickat från min iPhone med Tapatalk

Vilka funktioner är planerade att hanteras i FPGA:n?

[Fält]

huj, det var mycket. Testar senare.
Det är ingen tanke med nåt, jag bara klipper och klistrar hej vilt. Tänk oändligt med chimpanser med skrivmaskiner kommer för eller senare att skriva ihop ett av Shakespears mästerverk.

Tack!

Om du har en Pro Micro eller Micro med Mega 32u4 mcu så får du gärna prova det här som jag tjuvat ihop.

Den skriver mycket till terminalen, input capture tiderna (som jag inte provat), vad timers står på och tid sedan start. Räknarna nollställer sig som du ser ganska ofta då de räknar i ganska hög fart. Det gör att man måste hålla reda på om klockan slagit över mellan de två mätningarna, det gör inte koden ännu.

Jag började misstänka att mini väldigt tidiga Arduino micro går på 1MHz, så jag kom av mig lite och får kolla vidare i morgon.

Kod: Markera allt

//Input Capture Interrupt
//=======================
#include <Wire.h>
volatile unsigned int previous_capture1 = 0;
volatile unsigned int current_capture1 = 0;
volatile unsigned int previous_capture3 = 0;
volatile unsigned int current_capture3 = 0;
//============================================================================
void setup()
{
  Serial.begin(115200);
  
  
  //programming timer1 for input capture interrupt
  noInterrupts();
  TCCR1A = 0;             //initialize timer1 mode
  TCCR1B = 0;
  TCCR1B |= 0b11000010;   //set 8 prescaler, rising edge, noise canceler
  TIMSK1 |= 0b00100000;   //enable input capture interrupt

  TCNT3 = 0;              //initialize timer/counter3 register
  TCCR3A = 0;             //initialize timer3 mode
  TCCR3B = 0;
  TCCR3B |= 0b11000010;   //set 8 prescaler, rising edge, noise canceler
  TIMSK3 |= 0b00100000;   //enable input capture interrupt
  TCNT3 = 0;              //initialize timer/counter3 register
  interrupts();
}
//============================================================================
ISR(TIMER1_CAPT_vect)  //input capture interrupt ISR
{
  previous_capture1 = current_capture1;
  current_capture1 = ICR1;
}

ISR(TIMER3_CAPT_vect)  //input capture interrupt ISR
{
  previous_capture3 = current_capture3;
  current_capture3 = ICR3;
}
//============================================================================
void loop()
{
  unsigned int timercount11=TCNT1;
  unsigned int timercount12=TCNT1;
  unsigned int timerdiff1=timercount12-timercount11;

  unsigned int timercount31=TCNT3;
  unsigned int timercount32=TCNT3;
  unsigned int timerdiff3=timercount32-timercount31;

  float sekunder= (float) millis() / 1000;
  Serial.print("***********Tid sedan start:");
  Serial.print(sekunder);
  Serial.println("****************");
  Serial.println("******************Timers****************");
  Serial.println("Timer1:");  
  Serial.println(timercount11);
  Serial.println(timercount12);
  Serial.println(timerdiff1);
  Serial.println("Timer3:");
  Serial.println(timercount31);
  Serial.println(timercount32);
  Serial.println(timerdiff3);
  Serial.println();
  Serial.println("******************Input Captures****************");
  Serial.println("Timer1 previous capture:");
  Serial.println(previous_capture1);
  Serial.println("Timer1 current capture:");
  Serial.println(current_capture3);
  
  Serial.println("Timer3 previous capture:");
  Serial.println(previous_capture3);
  Serial.println("Timer3 current capture:");  
  Serial.println(current_capture3);

  
  delay(1000);
}

[lasse-a]

Det går kanske att porta till en billigare FPGA i framtiden? Jag har inte ens viljat tänka på FPGA även om jag vet att det är den bästa lösningen.

Det här är så lite logik att det får plats med råge i den billigaste FPGA. Ja, det får tom plats i den billigaste CPLDn (då snackar vi 50-100:- för ett färdigt experimentkort från Kina, lösa kretsar är ännu billigare) så det är inget problem.

(CPLDer kräver dessutom inte något externt minne för att ladda konfigurationen vid start, något alla FPGAer kräver, så det är ytterligare ett plus om man inte köper färdiga kort).

[lasse-a]

huj, det var mycket. Testar senare.
Det är ingen tanke med nåt, jag bara klipper och klistrar hej vilt. Tänk oändligt med chimpanser med skrivmaskiner kommer för eller senare att skriva ihop ett av Shakespears mästerverk.

Tack!

Om vi bortser från att Fält har visat hur man egentligen skall göra det så har jag hittat felet i din kod. Dvs. det som gör att den "bouncar" hela tiden, oavsett vad du gör förutom att stänga av dem helt och hållet.

Jag satte mig ner för att skriva om den, så jag kunde mäta med funktionsgenerator. Ja, den kommer aldrig att fungera bra eftersom vi bla har räknarinterrupt som slår när timer0 flödar över. Detta för att kunna mäta längre tid än en 16-bitars räknare räcker till. Koden som körs då stänger av avbrott ganska länge. (Jag och Fält grottar lite i det här i en tidigare tråd: viewtopic.php?p=3088017#p3088017 backa några inlägg för att få sammanhanget.) Jag tror mer på ESP32:ans timer capture interrupts här. Men de är ju tyvärr bara tre. Men jag tänkte ändå mäta för att se hur nära man kan få det.

MEN, nu var det ju inte det vi skulle prata om utan din avbrottskod:

Kod: Markera allt

void blink1() {
  if (bounce1 = true) {

    mictime1 = micros();
    bounce1 = false;
    detachInterrupt(digitalPinToInterrupt(2));

  }
}

Du har tyvärr fallit i en klassisk C-fälla, en vi alla varit i, så du är i gott sällskap bara så du vet.

Problemet är att C är liberalt vad gäller skillnaden mellan uttryck och kod som bara körs för sin sidoeffekt. I ett uttryck så beräknas något och värdet av uttrycket blir värdet av beräkningen. Exv. "x + 1;" Kod som bara körs för sin sidoeffekt är t ex "x = x + 1;" Här har vi först ett uttryck i högerledet som ger ett värde, och detta värde tilldelas (dvs lagras) sedan i variabeln x. Så långt inga problem, om det inte vore för det faktum att C tycker att den koden också lika gärna kunde få ett värde; så om den koden står i en position som kräver ett värde så tar C glatt värdet av x och använder det. Detta är praktiskt i satser av typen: "x = y = 3;" där både x och y får värdet 3, MEN det blir lätt problem i ett specifikt fall, nämligen när man skall jämföra något. I C så är jämförselseoperatorn två lika med-tecken ==, ett lika med tecken (=) är tilldelning.

Så i din if-sats ovan så jämför du inte om bounce1 är lika med true, och sedan kör if-satsen (eller inte) beroende på vad bounce1 är. Du tilldelar bounce1 värdet true. Sedan så behöver C ett värde för att bestämma vad den skall göra med if-satsen, och tar då glatt värdet true och eftersom det (alltid) är sant så kör den if-satsen.

Så if-satsen körs alltid oavsett värdet på bounce1. Det som avsågs var alltså snarare "if (bounce1 == true) {".

Detta är som sagt en extremt vanlig fälla som alla går i förr eller senare, och ibland så ser man kod skrivas "if (true == bounce1) {" istället eftersom det då inte kan bli fel. C-kompilatorn stoppar om den skulle se "if (true = bounce1) {" eftersom man naturligtvis inte kan tilldela ett nytt värde till en konstant. Då får man felmeddelande.

Sedan så behöver du göra de andra ändringarna också, men detta löser problemet med att dina interrupts alltid slår igenom, kontrollen för att se om det redan har slagit är som sagt inte där. Det ser bara ut så.

(Återigen får jag be om ursäkt på förhand för en alldeles för lång och detaljerad förklaring. Det är som sagt en yrkesskada... )

[lasse-a]

Och här är den uppsnyggade koden. Notera att jag ändrat "håll" på bounce1&bounce2 eftersom jag tycker det blir lättare att förstå (men spelar ingen roll egentligen, bara man är konsekvent).

Kod: Markera allt

// Mät skillnaden i tid mellan två signaler på pinne 2&3 mha avbrott

volatile unsigned long mictime1 = 0;
volatile unsigned long mictime2 = 0;

volatile bool bounce1 = false;
volatile bool bounce2 = false;

// ISR
void blink1() {
  if (bounce1 == false) {
    mictime1 = micros();
    bounce1 = true;
  }
}

void blink2() {
  if (bounce2 == false) {
    mictime2 = micros();
    bounce2 = true;
  }
}

void setup() {

  Serial.begin(115200);

  // Init pinnar och avbrott
  pinMode(2, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(2), blink1, FALLING);

  pinMode(3, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(3), blink2, FALLING);

}

void loop() {

  while (bounce1 == false && bounce2 == false) ; // Busy wait until both interrupts have triggered (note semi-colon)

  Serial.print("Mic1: ");
  Serial.print(mictime1);
  Serial.print(", Mic2: ");
  Serial.println(mictime2);
  Serial.print(", Diff: ");
  Serial.println(mictime2 - mictime1);

  delay(1000); // Wait one second

  mictime1 = mictime2 = 0;
  bounce1 = bounce2 = false; // Ready for new interrupts, NB must be last thing done and isn't 100% correct...

}

Jag har inte provkört den, ungarna har tagit över källaren, men du kan iaf utgå från den, den skall vara korrekt. (Berömda sista ord... )

[lone_wolf]

Sius ursprungliga lösning med kretsschema: https://patents.google.com/patent/USRE32123E/en
Dessutom flödesscheman för logiken

Verkar vara byggd med en analog frontend/mätkedja som filtrerar signalen och tar hand om dess dynamiska range.

Det här är allts från 1977, men de analoga filtren är fortfarande användbara.

[lone_wolf]

Och här är den uppsnyggade koden. Notera att jag ändrat "håll" på bounce1&bounce2 eftersom jag tycker det blir lättare att förstå (men spelar ingen roll egentligen, bara man är konsekvent).

Kod: Markera allt

// Mät skillnaden i tid mellan två signaler på pinne 2&3 mha avbrott

volatile unsigned long mictime1 = 0;
volatile unsigned long mictime2 = 0;

volatile bool bounce1 = false;
volatile bool bounce2 = false;

// ISR
void blink1() {
  if (bounce1 == false) {
    mictime1 = micros();
    bounce1 = true;
  }
}

void blink2() {
  if (bounce2 == false) {
    mictime2 = micros();
    bounce2 = true;
  }
}

void setup() {

  Serial.begin(115200);

  // Init pinnar och avbrott
  pinMode(2, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(2), blink1, FALLING);

  pinMode(3, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(3), blink2, FALLING);

}

void loop() {

  while (bounce1 == false && bounce2 == false) ; // Busy wait until both interrupts have triggered (note semi-colon)

  Serial.print("Mic1: ");
  Serial.print(mictime1);
  Serial.print(", Mic2: ");
  Serial.println(mictime2);
  Serial.print(", Diff: ");
  Serial.println(mictime2 - mictime1);

  delay(1000); // Wait one second

  mictime1 = mictime2 = 0;
  bounce1 = bounce2 = false; // Ready for new interrupts, NB must be last thing done and isn't 100% correct...

}

Jag har inte provkört den, ungarna har tagit över källaren, men du kan iaf utgå från den, den skall vara korrekt. (Berömda sista ord... )

I interruptservicerutiner brukar man stänga av interrupt; sker det här automatisk i Arduino, annars risk för rekursiv start av blink. rutinerna?

bounce1/2 används nu som flaggor/semaforer för kommunikation mot ISR rutinen, för att inte få sidoeffekter så är det säkrast att stänga av interrupt när de hanteras (dvs bounce1 = bounce2 = false;). Beror dock på kompilatorn om det här är ett problem i det här fallet.

[lasse-a]

Sius ursprungliga lösning med kretsschema: https://patents.google.com/patent/USRE32123E/en
Dessutom flödesscheman för logiken

Verkar vara byggd med en analog frontend/mätkedja som filtrerar signalen och tar hand om dess dynamiska range.

Det här är allts från 1977, men de analoga filtren är fortfarande användbara.

Bra googlat! Och vilket ovanligt detaljerat patent. Det märks att det har några år på nacken; är från den tiden då man inte patenterade vad skit som helst.

Skall jag läsa med nöje! Lite kul upplägg av mikrofonerna, har inte läst mig till än varför man gjort så.

Med stor sannolikhet så går det dock att förenkla idag. Dvs göra mer digitalt som var ohemult dyrt 1977.

[kattafan]

Häftigt!
Dock inte i närheten av det som används idag där mikrofonerna sitter inne i tavlan. Som jag fattar det på riktningen har dom här en ramp framför tavlan

[lasse-a]

I interruptservicerutiner brukar man stänga av interrupt; sker det här automatisk i Arduino, annars risk för rekursiv start av blink. rutinerna?

Japp. De är avstängda så det behöver man inte göra separat. (Det är ganska vanligt på enklare, billigare processorer).

bounce1/2 används nu som flaggor/semaforer för kommunikation mot ISR rutinen, för att inte få sidoeffekter så är det säkrast att stänga av interrupt när de hanteras (dvs bounce1 = bounce2 = false;). Beror dock på kompilatorn om det här är ett problem i det här fallet.

Ja. Det är därför det står att det inte är helt korrekt. Det var ett test för att se om ni är med.

Jag har inte tittat på den genererade koden så jag vet inte, men antagligen så är följande det hyperkorrekta sättet att göra det på att föredra.

Kod: Markera allt

noInterrupts(); 
bounce1 = bounce2 = false; // Ready for new interrupts
interrupts();