The fact that the sensors are not accurate is imho no argument to use math that adds additional errors. The relative errors add up.
That said, I agree with you that most applications do not need this level of accuracy.

Thanks,

If you want to use floating point values, more power to you, go for it!  NewPing FULLY supports doing this.  *YOU* have the ability to change the US_ROUNDTRIP_CM and US_ROUNDTRIP_IN values to whatever you want, or use ping() and do any other calculations you wish factoring in temperature, altitude, humidity, etc.

The fact is, my integer values are typically more accurate than when people try to over complicate things by using floating point values in attempts to get more accurate values.  But, if you're in search for the holy grail of ultrasonic measurement, use ping() and apply your magic formula.

This is *NOT* something that will be added to NewPing as it's outside the scope of the library to be any more accurate than it is now.  Because, to be more accurate you'd need a thermometer, and apply your own formula.  So, while this is a fine topic, it shouldn't be here as it will never be added to NewPing.  Heck, there's debate on the speed of sound, I'm just staying out of the fight.

Topic closed.

Hi Teckel,

did investigate the duration2cm() function here - http://arduino.cc/forum/index.php/topic,165860.0.html -
might be useful in your library.

I tried something similar in the past, but honestly it's not worth the extra cycles adding this type of code adds.  Basically, it's pointless to try to make the math more accurate than the sensor is.  Ultrasonic sensors are not very accurate anyway.  Also, there's actually an argument as to the speed of sound (everyone likes to use a different number).  This is why I settled on an integer and the value that I default to.  It provides very accurate distance results in typical indoor temperatures and does so very fast using very little program space.

Instead of getting into this battle, I avoid it.  Just use the ping() method which returns a ping time.  Then, use whatever math you want (based on temperature or whatever).  If you want to use a fraction and want to use a different method to calculate this (like the above linked example) that's fine also.

Keep in mind that NewPing is an ultrasonic ping library, not a floating point, math, or temperature library.  I'm sure you can find or develop a library that allows you to divide a floating point number without using floating point math.  This would be then just included in your sketch along with NewPing to calculate a distance at whatever accuracy level you desired.  But keep in mind that the sensor isn't that accurate anyway (only  about 1cm).  So all this effort may be wasted anyway.

Tim

[IS]

some ideas about accuracy...

i have just gotten my sr04 and played a lithe with it. i intend to use it to measure oil level in a tank. so accuracy is quite important.
after reading on the web there are two main points that seem to influence the accuracy of the sensor and both are not accounted for in the newping library:

- one is temperature. it would be nice to be able to set the temperature that newping uses for the conversion to cm/inces. depending on the temperaure the error can easily be in the range of 10% if temperature is not accounted for.

- the other one is the which echo is received and evaluated. if i do repeated measurements i notice that the results will be relatively near around two or tree that are themselves further apart. this looks like it is consistent with some articles that say this error comes from reading the second or third echo and not the first and should be especialy noticeable in the short range.

so to be able to make more accurate measurements i started reading 10 or 50 pings, iterating over all of them and throwing away all that are equal to the largest and all that are equal to the smallest and then averaging the rest. if there are non available after throwing the smallest and largest away i take the smallest. the conversion to cm is then done in float.

this seems to give very accurate and reproduceable results. doing this repeatedly in a range of 1cm to 1m gives identical results up to at least 1mm.

maybe a 'slow scan' option could add this to the newping library for applications where fast response times are not needed.

1) Because you need an outside thermometer to measure temperature, it was decided not to overly complicate the NewPing library.  However, NewPing *IS* designed to adjust with temperature.  Simply use the ping() method which gives you a time.  Then, do your own calculation of distance based on your thermometer attached to the Arduino.  In almost all situations, the default distance works well for average indoor temperatures.  But, if you need accuracy, you're going to need additional hardware and then (of course) you're going to need to do your own calculation.  But, NewPing will work with this situation just fine.

2) This isn't a problem with the library, nor can it be fixed in a library.  This is fixed by following the instructions in my sample sketches.  Basically, if you ping a second time too quickly after a previous ping, you can get an echo.  This can't be fixed by the library as it's only reading what the sensor outputs, which is a digital signal (the library has no amplitude information).  The solution is to simply heed my warnings in my sketches.  Which is to not ping too quickly.  Your pings shouldn't be more frequently than around once every 29ms.  If you're in a highly sonicly reflective environment, or your sensor is overly sensitive, you may need to increase this amount.  If it's not something fast moving (probably like in your case) ping once every second or two even.  That way, you can be assured that you're not reading an echo.  NewPing doesn't control the speed of the pings *YOU* do.  If you want to make it slow, just make it slow.  Maybe I'm missing something?

Tim

There are technically libraries out there that allow you to set the PWM frequency.  They are, however, typically labeled as audio "tone" libraries.  It doesn't matter if the library is designed for audio, it's still just a PWM library.  I've written some of these libraries, some of which will output PWM signals at up to the gigahertz range.

This interests me.  Particularly the part about the gigahertz range.  I haven't heard of this before.  Could you point me to somewhere that explains how this is done?

Sorry, must have been drunk, I meant MEGAhertz, not gigahertz.

One of my tone libraries (toneAC) does PWM control of two pins alternating at up to 2.66 MHz with an ATmega running at 16MHz.

Official site
Arduino Playground
Support forum

Sorry about the confusion.

Tim

Hi! Fantastic library.

I simply want to use 2 HC-SR04 sensors and use the result to turn on their appropriate LED when MAX_DISTANCE is less than 30.

SR04 #1 - turns on LED1 when MAX_DISTANCE is less than 30
            - turns off LED1 when MAX_DISTANCE is greater than 30

SR04 #2 - turns on LED2 when MAX_DISTANCE is less than 30
            - turns off LED2 when MAX_DISTANCE is greater than 30


I added an if/else statement in the pingResults() function, LED 1 turns ON and remains on when
either sensor is triggered.
What do I have to do to declare both sensor 1 and sensor 2 in the function?  

Sounds pretty simple but I'm kinda new at this so be gentle!  

Thanks.


Here's the sketch:

#include <NewPing.h>

#define SONAR_NUM      2
#define MAX_DISTANCE 30
#define PING_INTERVAL 33
//LED setup
#define LED_1   12
#define LED_2   13

unsigned long pingTimer[SONAR_NUM];
uint8_t currentSensor = 0;

NewPing sonar[SONAR_NUM] = {  
  NewPing(4, 5, MAX_DISTANCE),
  NewPing(6, 7, MAX_DISTANCE)  
};

void setup() {
  pinMode(LED_1, OUTPUT);
  pinMode(LED_2, OUTPUT);
  
  Serial.begin(115200);
  pingTimer[0] = millis() + 75;
  for (uint8_t i = 1; i < SONAR_NUM; i++)
    pingTimer = pingTimer[i - 1] + PING_INTERVAL;
}

void loop() {
  
  for (uint8_t i = 0; i < SONAR_NUM; i++) {
    if (millis() >= pingTimer) {    
      pingTimer += PING_INTERVAL * SONAR_NUM;  
      sonar[currentSensor].timer_stop();  
      currentSensor = i;                  
      sonar[currentSensor].ping_timer(echoCheck);
    }
  }


}

void echoCheck() {  
  if (sonar[currentSensor].check_timer())
    pingResult(currentSensor, sonar[currentSensor].ping_result / US_ROUNDTRIP_CM);
}

void pingResult(uint8_t sensor, int cm) {  // Sensor got a ping, do something with the result.
  // The following code would be replaced with your code that does something with the ping result.
  
    if (cm < MAX_DISTANCE) {  
      digitalWrite(LED_1, HIGH);
  }
     else {
        digitalWrite(LED_1, LOW);
  
  }
  
  for (uint8_t i = 0; i < SONAR_NUM; i++) {
  Serial.print(sensor);
  Serial.print(" ");
  Serial.print(cm);
  Serial.println("cm");
  }
Serial.println();
  
}

The 15 sensor example sketch is more for advanced users that require a multi-tasking type script where multiple things will be happening at basically the same time.  Therefore, your use is well outside these parameters.

Instead, simply use the basic one sensor example sketch and add a second sensor.

Basically, you're trying to make it much more complicated than it needs to be, which is why you're having problems.

Now, if you had an already event driven sketch and you wanted to add two sensors while still keeping your sketch event-driven, then using the 15 sensor sketch would be appropriate.

Tim

I discovered in a recent project involving an Arduino microcontroller that there was no method to change PWM frequency without directly manipulating low-level memory. As far as I can Google, there is no general purpose library that can change PWM frequencies on Arduino Microcontrollers. The internet is full of partial examples and code snippets for changing PWM frequency, but in the end I still had to consult the 400+ page sec sheet (http://www.atmel.com/Images/doc2549.pdf) to get the code for my Mega functional.
It is my speculation that the programmers at Arduino have not released any methods for changing PWM frequency because it is difficult to write a simple and intuitive wrapper for hardware timers that wont run the risk of confusing a beginner (the whole draw to Arduino in the first place). The hardware is has very specific limitations that present themselves in odd ways. Allow me to share a few:

• PWM behavior is determined by integrated components called timers. Every timer has two to four channels. Each channel is connected to a pin. Changing one pin's frequency requires changes to the timer it connects to. Which in turn changes the frequency of other pins connected to that same timer.
• Timer 0 is usually used for Arduino's time keeping functions, (i.e. the millis() function). Changing the frequency on timer 0 will break the time keeping functions you may or may not be using in other parts of your project
• There are two types of timer, 8bit and 16bit. Long story short, they have nuances that make common code difficult to implement without limiting one or the other.
• Creating custom frequencies (beyond messing with the prescaler) with an 8bit timer requires the sacrifice of one channel. In other words, each 8bit timer that creates a custom frequency loses the ability to perform PWM on one pin (the one connected to the A channel to be more precise). All Arduinos except the Leonardo have two 8bit timers, meaning that setting all timers to a particular frequency will sacrifice a total of two pins on said Ardiuno.

Regardless of this, I still felt it would still be worth while to make a library/wrapper for hardware timers so that I, and anyone else who chooses to use this, will not have to spend quite as many hours needlessly digging through blocks of bug prone bit wise and preprocessor slurry.

The library has five global functions:

InitTimers()	Initializes all timers. Needs to be called before changing the timers frequency or setting the duty on a pin
InitTimersSafe()	Same as InitTimers() except timer 0 is not initialized in order to preserve time keeping functions
pwmWrite(uint8_t pin, uint8_t val)	Same as 'analogWrite()', but it only works with initialized timers. Continue to use analogWrite() on uninitialized timers
SetPinFrequency(int8_t pin, int32_t frequency)	Sets the pin's frequency (in Hz) and returns a bool for success
SetPinFrequencySafe(int8_t pin, int32_t frequency)	Same as SetPinFrequency except it does not affect timer 0

The library also has five functions for each Timer 'object'. I could not get the code size down to what I felt was reasonable so I ditched C++ classes and did some fancy macro work instead. Each of these functions are technically preprocessor macros with nice self explanatory names that swap out for more cryptic functions inside the library header just before compile time. For timer 1 the functions are:

Timer1_GetFrequency()	Gets the timer's frequency in Hz
Timer1_SetFrequency(int frequency)	Sets the timer's frequency in Hz
Timer1_GetPrescaler()	Gets the value (not bits) of the prescaler. Don't know what this means? Don't worry about it, just use SetFrequency(int frequency)
Timer1_SetPrescaler(enum value)	Sets the prescaler*
Timer1_GetTop()	Gets the timer register's maximum value
Timer1_SetTop(int top)	Sets the timer register's maximum value
Timer1_Initialize()	Initializes the timer

*The prescaler is inconsistent among different timers. I figured using enumerators was the best solution because most types of invalid input will be caught at compile time. For a normal timer, use one of these as a parameter: ps_1, ps_8, ps_64, ps_256, ps_1024. If those give a type error, then the timer you are using is one of the inconsistent ones, and you should use psalt_1, psalt_8, psalt_32, psalt_64, psalt_128, psalt_256, or psalt_1024 instead.

If you want to mess with a different timer, just change the number (i.e Timer2_GetFrequency() to get timer 2's frequency). It is up to your discretion whether or not you want to use the timer specific functions. The global ones should be good enough for most situations.

With this Library, 16bit timers have a frequency range from 1Hz to 2MHz. 8bit timers have a range from 31Hz to 2MHz. As the frequency becomes larger, the smaller the range power duties for a pin becomes. It is technically possible to push the frequency to 8MHz, but the range of possible power duties get stupidly small by that point. To be sure the frequency was correctly set, be sure to check the return value. If you don't want to sacrifice any 8bit PWM pins, don't call the initialize function for that timer, try changing the prescaler to manipulate frequency instead. There are many tutorials on how the prescaler affects timers and this library contains methods that make easier and less bug prone to manipulate. So far, I have tested this library on an Uno and a Mega. This library should be compatible with all Arduinos except the Leonardo and Due. If you have an Arduino that is not a Mega or Uno, please test it and tell me how it went. If somebody has an oscilloscope on hand to verify the frequencies being generated are correct, that would also be helpful.

For now, consider this library to be in beta. Developments on this library are described in later posts.
Here are some of the current features of this library:

• Wraps timer specific properties (such as timer top and prescaler) with functions
• Has pin based (timer agnostic) functions
• Has functions for getting and setting frequency at the timer level and pin level
• Has tools for measuring timer resolution at the timer level and pin level

The latest is version .05
link: http://code.google.com/p/arduino-pwm-frequency-library/downloads/list

There are technically libraries out there that allow you to set the PWM frequency.  They are, however, typically labeled as audio "tone" libraries.  It doesn't matter if the library is designed for audio, it's still just a PWM library.  I've written some of these libraries, some of which will output PWM signals at up to the megahertz range.

Tim

this could be awesome if the library was also Due compatible

I don't find the Due relevant, so I don't consider support for it.  Also, as NewTone uses port registers and direct timer calls, it doesn't really work well for the Due which is totally different than the ATmega.

Tim

Yes, I set the maximum distance at 300 but then the sensors return 0's. All the sensors are pointing at a solid wall 250cm away, but the sensors are returning 0's rather than seeing the wall, thus I'm assuming out of their range. I thought it strange as the Hr04's measured/worked fine over this distance. I've tried different delay times to see if there is any interference, up to 100ms but it makes no difference to the readings

Are you sending the sensor 5v?  Other than that, must just be your sensors.

Tim

Hi Tim,

In the end I brought some Yourdunino SRF06's. They are accurate at their distance measurements but unfortunately their distance max's out at about 200cm, beyond that they return 0's. I was looking for something which would hopefully be accurate to about 350cm.... I have gone ahead and bought a few of Maxbotix XL EZ0 sensors. Do you think that I could modify your New Ping code to work with these sensors or would I need to start from scratch?

Did you set the maximum distance to higher than 200cm?  Mine work well to easily over 400cm.  Maybe it's the size of the object or how sonically reflective it is?  Try using a wall as your maximum distance measurements, that's what the distance specs use.

Tim

Hi have been trying to adapt to use it on Timer "4" on the mega
As i can not use it on Timer 1 as it then conflicts width my PWM signals on the MEGA 2560  ;-(
I am trying to drive a speedometer
as you see i have just tryed to change the 1 to 4 not sure i know what i am doing
Any reply greatly appriciatet ;-)

I have changed here

NewTone.h

#define TIMSK4 TIMSK //#define TIMSK1 TIMSK

NewTone.cpp

ICR4    = top;                     // Set the top.
  if (TCNT4 > top) TCNT4 = top;      // Counter over the top, put within range.
  TCCR4B  = _BV(WGM40)  | prescaler; // Set PWM, phase and frequency corrected (ICR1) and prescaler.
  TCCR4A  = _BV(COM4B0);
  TIMSK4 |= _BV(OCIE4A);             // Activate the timer interrupt.

TIMSK4 &= ~_BV(OCIE4A);   // Remove the timer interrupt.
  TCCR4B  = _BV(CS40);      // Default clock prescaler of 8.
  TCCR4A  = _BV(WGM40);     // Set to defaults so PWM can work like normal (PWM, phase corrected, 8bit).

ISR(TIMER4_COMPA_vect) { // Timer interrupt vector.

It doesn't just conflict with the PWM signals, it replaces them.  It's by design.  Instead, why not just use PWM for timer 4 for whatever else you're doing?

One of the main purposes of NewTone is to use a different timer than the standard tone library.

In any case, I don't really know the ATmega2560 to know off the top of my head if there's any differences between timer 1 and timer 4.  Are they identical?  For example, if timer 4 doesn't have all the features of timer 1, it won't work.  It doesn't appear it's identical as it has 3 pins tied to timer 4 while timer 1 only has 2.

Without diving into the ATmega2560 technical documentation, I'll be hard-pressed to help.

Instead, I would suggest using my ToneAC library (there's an alternate version which uses timer 2).  It's superior to NewTone anyway and is already written to use timer 2 and can be assigned to any pins.

Tim

Is there a way to adjust the sensitivity or have a minimum size of object/return to be used for the result? I ask because if you look at the attached picture you will see the HC-SR04 mounted tipped up at 10 degrees. It will always return the distance to the 1.3" x 2.5" rectangle of cardboard and will never return the distance to the wood door (I like that it does this). However, if I put the 1/16" hex key in the path like in the picture, the sensor will return this shorter distance once in a while. A larger .090" hex key will cause most all returns to be the hex key distance.
I have read to get the sensor well off of the floor, but I don't really have that option. I don't have hex keys in the path, but I used this as an example. Many real world surfaces can cause returns it seems.
Your very good median can be used for a small amount of stray results, but I have found that sometimes the extremely small object returns can be consecutive at times and bad numbers will get through the median. The oscilloscope shows that it must be very difficult to pick out the closest object, but I was hoping to have the ultrasonic ignore the very small returns. I know that this is not in NewPing, but I just wondered if anyone had changed what must be the firmware on the sensor itself.
Thank you.

As cyclegadget stated, putting the transmitting and/or receiving sensor(s) in a tube can focus the detection to a smaller range.  You can try different length tubes which will give different results.

Also, if you just want to block the ground, tilting it up slightly as you have done is a good method.  If that still doesn't give the desired results, you can add a shield below the sensors.  This is the same concept as the tube, but only blocks stray echos from below, not above.

Other than this, I haven't seen any ultrasonic sensor with any type of sensor adjustability.

Tim

Thanks so much Tim for your reply....

I'm in the UK so I think ordering from Yourduino is a little far... I was also looking at the http://www.maxbotix.com/ Maxbotix sensors, have you any experience of these? Prices seem wildly different but can't tell if that means a more accurate sensor?

I have taken your advice and changed my current patch to take into account 0 readings for non-distance people detection, but would really like to try to get accurate distance reading of people up to 3m... especially as the sensors throw out quite a few false 0 readings when there is not a person there....

Also before I said I would post the installation that I am using the sensors for, its here: http://www.apbsound.com/2013/drone/

All the best

Yourduino is far, but the sensors are cheaper and shipping low so it's not bad at all.  maxbotix.com makes some good sensors.  But, you need to use their libraries or make your own as they do things totally different than all the other ultrasonic sensors.

You can use the ping_median() method if you're not already to get a few readings which could weed out erroneous "no ping" readings.  Looking at the installation, it would seem that would work very well for ultrasonic sensors.  The far wall seems to be within 15 feet and it's a nice big flat wall.  But, maybe it's not working as well as you hoped for another reason.  For example, too much ambient noise or maybe because the sensors are hidden in the wall so the echo isn't as effective returning to the sensor.  I'd be curious how well it works if you placed the sensors outside the wall and there was no other noise in the room.  I know that doesn't help with your goal, but it could be useful for tracking down the problem.  Or, maybe it's the length of the wires you have running to the sensor?

Tim

Further investigation shows similiar issues with a sharp ir rangefinder being powered from the same rail. Is my issue the way in which I ran this 5v and gnd from the arduino? I connected a 5v pin to one line of pins and the gnd to another line of pins and I feed my sensors from this rail

Keep in mind that you set the max distance to 100cm.  Any reading beyond 100cm will return a zero (0) result.  For testing, you may want to set the max distance to 500cm (or leave blank and it defaults to 500cm).  You should only set a max distance if you really need to set it.  For example, you don't want to measure beyond a certain point, your sketch needs to do a bunch of other processing so you need it to timeout quickly, etc.  For "hello world" and testing, you should always either set the max distance to 500 or not set it at all (defaulting to 500cm).  Also, using a delay of at least 100ms (1000ms is even better as you have) while testing, especially if you're having a problem.

Many times, there isn't a problem, it's just that it's not returning what you would expect, because you've unknowingly set it up that way.

Tim

Would NewPing work with a SRF08?

I've been using a HC-SR04 but I've looking for something more accurate at longer distances, to sense body movement accurately up to 3m, is the SRF08 much better?

Or any other suggestions?

The HC-SR04 recognises a body up till about 1.2m, then further away the sensor reports 0, as I guess its sending out a signal but not receiving it back.... but if I hold up a board of wood it sends back an accurate reading up to about 3m
 

All the sensors are basically the same, with the same transducers and amps in most cases.  There's just slight differences (like timeouts).  I have several kinds and I would consider most to be almost identical.  Also, keep in mind that the HC-RS04 is not made by one company, many make them, with slight differences.  It could be that you just not one that wasn't too good.

Also, the SRF08 is not better just because the number is bigger.  It's not like it's version 8 so it's better than version 4.  The SRF08 is much larger, uses a lot more power, more expensive, and doesn't use the same interface at all, it uses I2C.  Instead, I would opt for the SRF06 from Yourduino.  There are other models of the SRF06 that have a different interface and connection header.  Those won't work with NewPing as they are very rare.  But, the SRF06 from YourDuino works very well with NewPing and is the best working sensor that I have.  It uses the least amount of power, fastest startup time, and has the longest range of any sensor I have.  The owner of YourDuino is a regular on this forum too as a bonus.

So, I would suggest either trying to buy a few additional cheapo eBay HC-RS04 sensors as you may have better luck.  Or, go with the SRF06 from YourDuino (4 pins).  Keep in mind that ultrasonic sensors are affected by sound absorbing materials, like clothing.  It won't work as well detecting detecting a dog as it will a flat board.  But, keep in mind that this still may give you what you want.  For example, having the sensor hit a far wall and get the distance (say 300cm).  When someone walks in front of the sensor, it will either bounce off and give a distance reading of say 150cm.  Or, maybe all the sound is absorbed so it gives a reading of zero.  That too could be used as a detection trigger, as normally it reads 300cm.  So, whenever there's a reading of anything less than say 280cm (all the way to 0) would mean something was in the way of the sensor.  This may not work in your situation, but it does in some (if the far wall is within the sensor range).

Tim

Well, you could simply use the existing bootloader with a 2MHz crystal, at which point it would run at (115200*16/2 = 14400bps)
You might still want the custom fuse settings for the lower speed crystal; you'd probably have to use avrdude directly to program them.  Neither the optiboot makefiles nor the Arduino IDE has a way to JUST program fuses, but it might be possible.

Teensy is "real" USB, so any speed you specify is just "emulated", I think.

That was one of the first things I tried.  It attempted to work, but failed.  It was like the baud rate was close but slightly off or something.

Tim