Related to Post 14
Surprisingly little as they are all triggered at the same time. the echo pins rise at the same time and only fall when the closest object reflects back. the object needs to be in line with the sensor to be detected. so there are a lot of holes.
The Code I posted could handle up to:
16 sonar units on a single Arduino UNO. Thus leaving pins 0, 1 for serial communication to another device with the data.
// enable interrupt for pin...
//Select the pins you want to use for input
//pciSetup(0); //Caution this pin is Used for Serial Communication
//pciSetup(1); //Caution this pin is Used for Serial Communication
//pciSetup(2); //This is my trigger pin
pciSetup(3);
pciSetup(4);
pciSetup(5);
pciSetup(6);
pciSetup(7);
pciSetup(8);
pciSetup(9);
pciSetup(10);
pciSetup(11);
pciSetup(12);
pciSetup(13);
pciSetup(14); // A0
pciSetup(15); // A1
pciSetup(16); // A2
pciSetup(17); // A3
pciSetup(18); // A4 // note: this is used for i2c communications
pciSetup(19); // A5 // note: this is used for i2c communications
These are all interrupt triggered pins so other code could be running and the values would be gathered as needed.
This is my creation and I've done a lot with this base code sense
for example:
Arduino_Interrupts is a library that includes several types of timers all set to connect to any pin of the arduino
volatile uint16_t RCRemote(uint8_t Pin, uint32_t cTime, uint32_t Pins,bool ValidRC = true); // Radio Controller remote
volatile int16_t Ping(uint8_t Pin, uint32_t cTime, uint32_t Pins); // Ultrasound Ping sensor
volatile int8_t Encoder(uint8_t ClockPin, uint8_t DataPin, uint32_t Pins,bool HalfStep); // Encoder
volatile int8_t Switch (uint8_t Pin,uint16_t cTime,int16_t debounceTime,bool OnRise); // Switch
volatile uint16_t SampleTime(uint8_t Pin, uint32_t cTime, uint32_t Pins,bool OnRise); // Sample Time
volatile int32_t Tachometer(uint8_t ClockPin, uint8_t DataPin, uint32_t cTime, uint32_t Pins); // Tachometer
As you can see the interrupts can easily be used for all these items. My Interrupts sketch allows any pin to be used as interrupts. including the ultrasound sensor
Here's an example sketch that has interrupts set for an RC Remote control 2 push buttons an ultrasound ping sensor and 1 encoder set at 4 steps per pulse cycle
This is the same thing as the attachInterrupt() function but with all pins on the Arduino UNO (atmega328p)
#include "Interrupts.h"
InterruptsClass Interrupt;
volatile long EncoderCounter = -2;
float microsecondsToInches(long microseconds)
{
// According to Parallax's datasheet for the PING))), there are
// 73.746 microseconds per inch (i.e. sound travels at 1130 feet per
// second). This gives the distance travelled by the ping, outbound
// and return, so we divide by 2 to get the distance of the obstacle.
// See: http://www.parallax.com/dl/docs/prod/acc/28015-PING-v1.3.pdf
return (float) microseconds / 74 / 2;
}
float microsecondsToCentimeters(long microseconds)
{
// The speed of sound is 340 m/s or 29 microseconds per centimeter.
// The ping travels out and back, so to find the distance of the
// object we take half of the distance travelled.
return (float)microseconds / 29 / 2;
}
void setup() {
Serial.begin(115200); //115200
Serial.println(" testing");
// put your setup code here, to run once:
pinMode(9, OUTPUT);
Interrupt.onInterrupt([](uint32_t Time, uint32_t PinsChanged, uint32_t Pins) {
sei(); // re enable other interrupts at this point,
Interrupt.PinCallBack(Time, PinsChanged, Pins);
});
Interrupt.onPin(4, INPUT_PULLUP, [](uint32_t Time, uint32_t PinsChanged, uint32_t Pins) {
if (Interrupt.CheckPin(4)) { // rising
Serial.println(" Pin 4 Rising \t");
} else { // Falling
Serial.println(" Pin 4 Falling \t");
}
});
Interrupt.onPin(5, INPUT, [](uint32_t Time, uint32_t PinsChanged, uint32_t Pins) {
uint16_t RCTime = Interrupt.RCRemote(5, Time, Pins, true);
if (RCTime) {
Serial.print(" RC Time:");
Serial.print(RCTime);
}
});
Interrupt.onPin(6, INPUT, [](uint32_t Time, uint32_t PinsChanged, uint32_t Pins) {
unsigned int PingTime = Interrupt.Ping(6, Time, Pins);
if (PingTime) {
Serial.print("Ping \t");
Serial.print(microsecondsToCentimeters(PingTime));
Serial.println("cm");
}
});
Interrupt.onPin(9, INPUT_PULLUP, [](uint32_t Time, uint32_t PinsChanged, uint32_t Pins) {
Serial.print("Switch \t");
Serial.println(Interrupt.Switch(9, Time, 1000, false));
});
Interrupt.onPin(10, INPUT_PULLUP, [](uint32_t Time, uint32_t PinsChanged, uint32_t Pins) {
Serial.print("Switch \t");
Serial.println(Interrupt.Switch(10, Time, 1000, false));
});
Interrupt.onPin(11, INPUT_PULLUP, [](uint32_t Time, uint32_t PinsChanged, uint32_t Pins) {
Serial.print("Switch \t");
Serial.println(Interrupt.Switch(11, Time, 1000, false));
});
Interrupt.onPin(12, INPUT, [](uint32_t Time, uint32_t PinsChanged, uint32_t Pins) {
EncoderCounter += Interrupt.Encoder(12, 13, Pins, true);
Serial.print("Count ");
Serial.print(EncoderCounter);
Serial.print("\t Encoder \t");
Serial.println(Interrupt.Encoder(12, 13, Pins, true));
});
Interrupt.onPin(13, INPUT, [](uint32_t Time, uint32_t PinsChanged, uint32_t Pins) {
EncoderCounter -= Interrupt.Encoder(12, 13, Pins, true);
Serial.print("Count ");
Serial.print(EncoderCounter);
Serial.print("\t Encoder \t");
Serial.println(-1 * Interrupt.Encoder(12, 13, Pins, true));
});
}
void loop() {
// put your main code here, to run repeatedly:
int t = 100;
static unsigned long _ETimer;
if ( millis() - _ETimer >= (t)) {
_ETimer += (t);
Serial.print(".");
digitalWrite(9, LOW);
delayMicroseconds(1);
digitalWrite(9, HIGH); // Trigger another pulse
delayMicroseconds(10);
digitalWrite(9, LOW);
}
}
So as you are reading along you all of a sudden find this:
[](uint32_t Time, uint32_t PinsChanged, uint32_t Pins) {
EncoderCounter += Interrupt.Encoder(12, 13, Pins, true);
Serial.print("Count ");
Serial.print(EncoderCounter);
Serial.print("\t Encoder \t");
Serial.println(Interrupt.Encoder(12, 13, Pins, true));
}
What is this??? It is what is called a Lambda function, an anonymous function, or basically a function without a name.
This could have been written as :
void MyFinction (uint32_t Time, uint32_t PinsChanged, uint32_t Pins) {
EncoderCounter += Interrupt.Encoder(12, 13, Pins, true);
Serial.print("Count ");
Serial.print(EncoderCounter);
Serial.print("\t Encoder \t");
Serial.println(Interrupt.Encoder(12, 13, Pins, true));
}
// with this in the startup() function
Interrupt.onPin(12, INPUT,MyFinction );
but I decided to use lambda functions in the startup for my test example.
The "onPin" function handles setting up the correct interrupt on that pin as well as handling the callback function.
If you are looking for more I could help you with the interrupt class I created.
Z
