Prototype Boards

I've had a look at some old code that I used that used interrupts and as I can see you setup the interrupts in the setup part of the code

attachInterrupt(0, Start, FALLING);
attachInterrupt(1, Stop, FALLING);

0 = pin 2, 1 = pin 3, "start" and "stop" are the names of the functions that get called when the interrupts are triggered and the falling indicates that the level goes from high to low to trigger the interrupt.

Thanks for the replies, very helpful.

This is part of the code that I want count with from the sensor. It will eventually have more zones and successfully looped using the small delay when I tried it on my breadboard.

It is my first attempt with Arduino and although I'm sure it could be improved no end I was pleased to get it running with some help from a friend.

Due to bringing the wrong memory stick with me I do not have the version where I tried incrementing using attached interrupt, sorry.

I did think that perhaps I should practice adding attached interrupt to blink as pratice when I return?

#include <Wire.h> // Comes with Arduino IDE
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); // Set the LCD I2C address

//int ledPin = 13;
int ledPin = 2;
int switch1 = 3;
int count;

void setup()
{
Serial.begin(9600); // Used to type in characters
lcd.begin(16, 2);// set up the LCD's number of columns and rows:
lcd.setCursor(2, 0); // Print a message to the LCD.
lcd.print("Rail Squirt";
delay (2000);
lcd.setCursor(0,1);
lcd.print(" by Peter Bell";
delay (2000);
lcd. clear();
lcd.print(" Version 2.7M"; //Version
lcd.setCursor(2, 1);
lcd.print(" 10-10-18";
pinMode(ledPin, OUTPUT);
delay (4000);
lcd. clear();
delay(1000);
}
void loop()
{

Serial.begin(9600);
Serial.println(count);


lcd.setCursor(2, 0);
lcd.print("Zone"; // ZONE 1 OFF
lcd.setCursor(9, 0);
lcd.print("1 OFF";

if (count > 155 && count < 175) {
digitalWrite(ledPin, HIGH);// output on

lcd. clear();
lcd.setCursor(2, 0);
lcd.print("Zone"; // ZONE 1 ON
lcd.setCursor(9, 0);
lcd.print("1 ON";
}
lcd.setCursor(9, 0);
lcd.print("8 ON";

if (count > 175 && count < 1500) {
digitalWrite(ledPin, LOW); //output off
lcd. clear();
lcd.setCursor(2, 0);
lcd.print("Zone"; // ZONE 8 OFF
lcd.setCursor(9, 0);
lcd.print(" END";

}

count ++ ;
lcd.setCursor(6,1);
lcd.print(count);
delay(200);

if (count == 1500) count = 0; //re-sets
lcd. clear();
}

I think to comply with preferred method this should be

attachInterrupt(digitalPinToInterrupt(2), Start, FALLING);

attachInterrupt(digitalPinToInterrupt(3), Stop, FALLING);

Yes you are right, but on a nano it compiles and works fine using int.0 and int.1.

Looks like interrupt is being well covered thanks. Unfortunately Unable to try anything at present but looking forward to it

The other method mentioned by Dave is “spin digitalRead() in a loop” Perhaps that could be an alternative as once the code has been activated by an impulse it runs then just sits waiting for the next pulse.Is there an example of that somewhere? That would help—-thanks Peter

Forgot to say that the input is pretty slow, between 0–5hz

I have some code that I wrote for an air rifle chronograph that detects a pellet breaking a beam then measuring the time taken before the second beam is broken then sending the time via bluetooth.

This code basically sits waiting for a pin to be triggered then does something then goes back to wait a again, you could probably adapt t his code, it's very simple really.

I have details on my blog here www.gadjet.co.uk

Edited By Phil Grant on 11/10/2018 09:34:40

My chronograph code is measuring events around 200uS apart so it should be more than capable enough.

Well here's Pete's code modified to increment count whenever pin 3 is grounded.

Bit more complicated that it should be because I use a different version of the LiquidCrystal library and only have a 20x4 display.

Testing by tapping a lead from pin 3 to ground. It works, but as noted in the code, it detects contact bounce galore! Debouncing is a separate issue and, as the best way of fixing it depends on Pete's input circuit, I won't cover it in this post.

#include <Wire.h> // Comes with Arduino IDE
#include <LiquidCrystal_I2C.h>

// SoD : there are a few different LiquidCrystal_I2C libraries. Changed to use the one I have

// LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); // Set the LCD I2C address
LiquidCrystal_I2C lcd(0x3f,20,4);  // SoD's display has LCD address to 0x3f for a 20 chars x 4 line display

//int ledPin = 13;
int ledPin = 2;
int switch1 = 3;

volatile int count; // SoD: Changed to volatile.

void switch1InterruptServiceRoutine()
{
  // SoD: Executed when an interrupt is received on the attached pin
  // Note: code is potentially too simple for direct use with a mechanical switch
  //       because the ISR will trigger repeatedly if the switch contact bounces. (As they do!)  
  //       See 'debouncing' on web

  count++;
}

void setup()
{
  Serial.begin(9600); // Used to type in characters
  //lcd.begin(16, 2);// set up the LCD's number of columns and rows:
  lcd.init();  lcd.backlight(); // needed for SoD's version of the LiquidCrystal library

  lcd.setCursor(2, 0); // Print a message to the LCD.
  lcd.print("Rail Squirt";
  delay (2000);
  lcd.setCursor(0,1);
  lcd.print(" by Peter Bell";
  delay (2000);
  lcd. clear();
  lcd.print(" Version 2.7M"; //Version
  lcd.setCursor(2, 1);
  lcd.print(" 10-10-18";
  pinMode(ledPin, OUTPUT);

  delay (4000);
  lcd. clear();
  delay(1000);

  // SoD - register the interrupt service routine
  // Note 'FALLING' means that switch1 is normally HIGH. The interrupt is triggered whenever switch1 goes low
 
  pinMode(switch1, INPUT_PULLUP );  // SoD: make the interrupt pin normally HIGH to detect FALLING

  attachInterrupt( digitalPinToInterrupt( switch1 ), switch1InterruptServiceRoutine, FALLING );
}

void loop()
{
  // Serial.begin(9600); SoD: already declared in setup(), only needed once
  Serial.println(count);
 
  lcd.setCursor(2, 0);
  lcd.print("Zone"; // ZONE 1 OFF
  lcd.setCursor(9, 0);
  lcd.print("1 OFF";
 
  if (count > 155 && count < 175) {
    digitalWrite(ledPin, HIGH);// output on
    lcd. clear();
    lcd.setCursor(2, 0);
    lcd.print("Zone"; // ZONE 1 ON
    lcd.setCursor(9, 0);
    lcd.print("1 ON";
  }
  lcd.setCursor(9, 0);
  lcd.print("8 ON";
 
  if (count > 175 && count < 1500) {
    digitalWrite(ledPin, LOW); //output off
    lcd. clear();
    lcd.setCursor(2, 0);
    lcd.print("Zone"; // ZONE 8 OFF
    lcd.setCursor(9, 0);
    lcd.print(" END";
  }
 
  //  count ++ ; SoD: replaced by ISR
  lcd.setCursor(6,1);
  lcd.print(count);
 
  delay(200);   // SoD: may not be necessary, best to avoid delay() if possible.
 
  // if (count == 1500) count = 0; //re-sets
  if ( count >= 1500 ) count = 0;  // SoD: safer reset!  Interrupts mean count==1500 might be skipped.  
  lcd. clear();
}

Edited By SillyOldDuffer on 11/10/2018 11:51:36

Edited By SillyOldDuffer on 11/10/2018 11:52:51

Just for interest I discovered a link to a site that uses blockly to graphically code for Arduino and other languages, this could be very useful for those not confident in using the Arduino IDE C code editor, this basically creates the code by dragging graphical block onto a sheet as required then paste to code into the Arduino IDE.

**LINK**

To use the editor click on the US flag on the left under 'blocklyduiuno"

Dave, Many Thanks for adding the code and explanations, just trying to work my way through them on a WiFi hotspot thats worse than dial up used to be.

At present it wont verify with a mysterious message (at least to me!) "of expected '' before ';' token" on the first LCD print up from the end of the sketch. Cannot spot anything obvious--looks the same as the one I listed and that verifies ok--perhaps I've lost some some syntax somewhere?

Phil, thanks for the blockly info, never heard of that for Arduino before--I'll explore.

Not sure where all the smileys came from though.

Peter

Hi Peter,

It's the curse of the smileys. The forum's editor 'helps' by converting the character strings once used to make text smileys and the like into emoticons. In the good old days before graphics a winky was a colon followed by a right bracket. Trouble is these combinations appear in computer source. As the editor also applies other officious format rules (like removing white-space on the left), it's hard to publish computer source code without having it subtly mangled!

Here's a dropbox link to the code I ran on my Nano. Note that you need to get rid of the changes I made to suit my particular version of LiquidCrystal which differs in the way displays are initialised.

Dave

Sadly, it appears to be spreading to other forums

Neil

That's alright. Just use uuencode .

Edited By Mark Rand on 12/10/2018 18:40:57

Hi Dave,

I must admit I thought that cut and past was just that, never realised what the editor was doing by tangling things around like that, another lesson learned.

The drop version works perfectly once I restored my lcd so many thanks for your help, still untangling what its all doing but its great to be learning and making progress at the same time. The switch bounce is horrendous but at least the serial numbers agrees with the lcd. The software solutions look very involved in the versions found so far so I'll try adding some r&c to see that the effect is. It may be ok in real life as I'm using a proximity sensor but I dont know what the rise time is yet.

You mentioned earlier "spin digitalRead() in a loop until a pulse is detected, then count it." as an alternative to attachinterrupt, could you point me to some info on it? Thanks

Peter

Peter,

Here is some code I wrote to check for a pin going low then counting microseconds before another pin goes low and then sending the value out over serial.

This code sits in the "wait state" (Spinning?) until the pin goes low it then changes to another "monitor state"

Please ask any questions you might have, I hope this is sort of what you're after.

Serial.println("Chrono SW Ver 1.00";

// Serial.print("Duration\t";

//Serial.println(" uS";

Edited By Phil Grant on 13/10/2018 10:58:15

Hi Peter,

I've modified your code to show how it's done. It's on Dropbox.

Phil's example is more complicated because it does some software debouncing as well.

Depending on the application, it's often easier to provide hardware debouncing. The simplest method is just to put a capacitor (about 100nF not critical) across the switch contacts. It prevents 'FALLING' or 'LOW' being detected until the switch has been held down for several milliseconds, which tends to eliminate bounce. For more demanding applications you could wire up an NE555 as a debouncer, or a comparitor, - even better - a Schmitt Trigger chip. Much depends on what you're doing and how bad the switch is.

A very simple software debouncer might change the spin loop in the example based on your code to look like this:

// Spin waiting for input

while ( true ) {
if ( digitalRead( switch1 ) == LOW ) {
delay(50);
if (digitalRead( switch1 ) == LOW )
break;
}
}
// To get here the switch was operated
count++;

All it does is insist on two reads detecting LOW inside a time window before counting.

Debouncing is such a common problem that there are a few Arduino libraries in the Library Manager to provide software debouncing. I've tried Bounce2 - it's much smarter and more general than my simple example, for example it can manage several switches, but you might prefer one of the others. Bit of a learning curve with them.

Dave

Edited By SillyOldDuffer on 14/10/2018 17:15:43

My preferred way of dealing with bounce is to use interrupt routines to set a flag and not re-enable them until I've dealt with the switch routine.

This enables me to deal with inputs when and where I want to without affecting time-critical processes with long interrupt routines.

If you use inline switch detections, it's usually easiest to plan your code so you don't test for a second switch condition twice within the bounce period.

Neil

Hi Dave,

Thanks for all that, your description on debounce sounds logical. Yes a 100nf almost fixes it, adding a 1k resistor in series completely cures it as far as I can see. I'll have a look at the bounce libraries, a quick search reveals a lot to choose from.

Thanks also for the spin, makes sense apart from the syntax I'm afraid. The curly brackets with the semicolon inside are used to end a statement according the reference? { ; } I'm sure there's a simple explanation!

// Spin waiting for input

while ( digitalRead( switch1 ) == HIGH ) {
// Do nothing
;
}

Also adding a LOW digital read version first stops it just rolling through so that it increments each complete input cycle, what is the advantage of interrupt which (to me!) appears to be doing the same job?

Peter

Thanks Neil, I'll have to work on that one once I get my head around the present learning!

Peter