Posts with «arduino» label

aMaze

Primary image

What does it do?

Solve's a maze and remembers the quickest route.

aMaze is A Maze solving robot.

Custom build using an Arduino bootloaded atmeag328p as the brain, a SN754410 as Motor Control, all wired on a solderless breadboard and fitted to a laser cut chassie designed by myself.

Cost to build

$90,00

Embedded video

Finished project

Complete

Number

Time to build

40 hours

Type

URL to more information

Weight

450 grams

read more

Let's Make Robots 05 Jul 18:27
6v  arduino  arduino 328  breadboards  dfrobot 6v  indoors on a maze  maze solving robot  pololu qtr digital array  

Try this....

Take a look at this:

http://cubloc.com/product/01_01cb210.php

It LOOKS like an Arduino (but its not). Same basic Arduino feature set. (add a power switch and a little more neat stuff)

It runs ,,,,,, tada ,,,,,, BASIC!  (Don't run, shake or shiver!)

(It looks one HECK of a lot like P-BASIC (STAMP 2) but has more commands and floating point.)

The editor can be downloaded and looks nice, but nothing special.

The manual looks nice and well organized and is BIG, but again is nothing special.

It costs $29

read more

Let's Make Robots 05 Jul 01:37
arduino  basic  ladder logic  new  other  

[RobB's] house has no light switches

So [RobB] wanted to take out all the light switches in his house. His plan was to replace them with a system that could be operated from his smart phone. But his wife insisted that there still must be some way to control the lighting directly — we have to agree with her on that one. The solution was to develop a system that switches the lights via a touch sensor or by Bluetooth.

The touch part of the project is pretty easy. He coated the back of a blank outlet plate with tin foil and hooked it to a microcontroller with a couple of resistors. He’s using an ATtiny85, which can be programmed using Arduino sketches, so the software side is made easy by the CapSense Library. The chip also uses the software serial library to communicate with a Bluetooth module. You can see the result of both in the demo video after the break.

Of course you need to throw a relay in there to switch mains, and find a way to power the uC and Bluetooth module. [RobB] went with a tiny plug-in USB power converter and managed to fit everything in a single-gang switch.


Filed under: home hacks
Hack a Day 04 Jul 15:02
arduino  attiny85  bluetooth  capsense  home automation  home hacks  light switch  relay  

Nerf gun prototype 1

The Santa Cruz Robotics Club met again today, for the first time in over a month.  The current project is not the underwater ROV (we’re all getting very tired of waterproofing problems), but an automated Nerf gun.

The club members came up with some very ambitious plans for the Nerf gun (which included getting a Raspberry Pi and doing image processing to have a self-aiming gun), but I’m making them build quick-and-easy prototypes to try out their ideas one step at a time.  I don’t think I can get an Raspberry Pi this summer—the companies doing the distribution aren’t taking more orders (just expressions of interest) and they don’t expect to clear the current backlog until September at the soonest.  They are doing batches of 100,000 units, and that doesn’t seem to be enough to shrink the lead time—if anything, the lead time is growing.

So, giving up on image processing for this summer, there are still a lot of things to build.  For today’s four-hour meeting (which included a 1-hour trip to the hardware store and a fifteen-minute snack break), the goal was simply to test out the basic launcher concept: an air reservoir pressurized by a bike pump, a solenoid valve, and a barrel.

The first prototype. The air reservoir is about 18″ of 1-½” PVC pipe on the left, and the barrel is about 24″ of ½” PVC pipe on the right.

The biggest problem was that the valve has ¾” male pipe threads, but we wanted 1-½” PVC pipe for the reservoir (because we had a piece handy—we may build a bigger reservoir later) and ½” PVC pipe for the barrel (because Nerf darts just fit inside—probably Nerf guns were prototyped with PVC barrels).  Our hardware store run was to get threaded adapters to make things fit.We wanted everything to be joined with screw threads, so that we could disassemble the components and replace them or add elbows as needed.

Note that the ½” PVC pipe is also a good size for compressed-air paper “rockets”.  The term “rocket” is a misnomer here, as all the acceleration occurs while the rocket is on the launcher—it is modeled more like a gun than like a rocket. (But my soda-bottle rocket simulator can model these paper bullets also.)  It would probably best to have a shorter barrel for doing rocket launching—just the length of the rocket and no more, since the longer barrel results in more pressure loss with no gain in launch speed.

The bicycle valve glued into a ½” female-threaded end cap was one I’ve had for a long time, as part of a soda-bottle rocket launcher. I had two of them, and both failed in testing today (the Barge cement holding the valve stem in failed—we’ve now reglued them with a different cement), though we managed some testing before the failure.

The solenoid valve we used was the same model (sold by Sparkfun) as the one used for the vacuum bottle on the ROV.  It has ¾” male pipe threads on each side.  To make it air-tight we had to disassemble it and grease the rubber membrane thoroughly with vaseline or faucet grease, but we had done that months ago, so it did not need to be done today.  The valve only works in one direction, but the high-pressure side is clearly marked by a metal intake screen, so assembling it the right way around is easy.

I was not sure that the solenoid valve would work in this application. It is not the model of valve that the compressed-air “rocket” people have used—those valves cost about twice as much and have female threaded ends rather than male threaded ends. I think that the mechanism they use may open up a bigger channel for air or water than the cheap solenoid valve sold by Sparkfun.

My first concern was that I did not know whether the valve would open up wide enough and fast enough to let a blast of air through to get a clean launch.  Second, I did not know whether we could open and close the valve fast enough to retain pressure in the reservoir for doing multiple shots.

We controlled the solenoid valve with an Arduino and the Hexmotor motor-control board (which is really overkill for one solenoid—a single power transistor would be enough to interface the Arduino to a solenoid, but I did not have one handy).  My son wrote an Arduino program to allow us to experiment with the duration of the solenoid pulse.  If it were too short, the Nerf dart would not leave the barrel.  If it were too long, air pressure would be wasted.  He allowed for 100 µsec increments in pulse duration, under control from commands on the USB serial line.

Because the glue they used takes 24 hours to set properly, we only tested at low pressure today (20–30 psi).  At those pressures, a 16 msec pulse was not long enough for the dart to clear the barrel, but a 19.2 msec pulse was easily long enough. We were also able to launch a 14g paper “rocket” left over from Maker Faire, though it did not go as high as the approximately 1.6g “Nerf” darts (I think several of the foam darts we have a different brand). We would not have expected it to go as high, since it was only accelerated for its 11″ length, not the 24″ length of the barrel for the darts, and it weighed a lot more.

One thing I thought about was monitoring the air pressure in the reservoir electronically. I doubt that we’ll put a pressure sensor in the reservoir, though, as the sensors I have only go up to 250 kPa absolute (about 21 psi above atmospheric pressure—about as low as we could fire with).  Freescale makes a 145psi (1000 kPa) sensor, the MPX5999D, but it is a differential sensor without port tubes (so would be difficult to mount) and it costs $13.

Perhaps the other thing worth doing today is to analyze how fast the Nerf dart should be going as it leaves the barrel, and how high it should fly if we shoot it straight up.  The physics here is fairly simple, if we assume that opening the solenoid valves connects us to a constant-pressure source. (In practice, we saw about a 10psi or 70kPa drop in pressure after one shot. If the pressure is P, then the force on the dart is P*area.  The cross-sectional area of the foam dart is a little hard to measure, because of the squishiness of the foam, but the inside diameter of the barrel is 1.45cm, for a cross-sectional area of 1.65 cm^2. At 140 kPa (about 20 psi), the force on the dart would be 23 Newtons.  That force is applied for about 60 cm (the length of the barrel), for a total energy of about 14 Joules.

We can use the kinetic energy of the dart to get its speed (E = ½ m v2), so for 140 kPa, the dart should leave the barrel at about 130 m/s or 290 mph. I suspect that we are not getting anywhere near that speed, for several reasons, including leakage of air around the dart, limited speed of air moving through the valve, and friction of the dart in the barrel (mainly from the pressure wave in front of it, but also from rubbing on the sides of the barrel).

We can also use the kinetic energy of the dart to estimate how high it would fly (ignoring air resistance, which is obviously hugely important for a low density object like a foam dart). The potential energy of a mass at height h is , so the height it would go without air resistance is . For 14 Joules and 1.6 grams, that would be almost 900m. I think that 20m is a more reasonable estimate for the height the dart went, though I never could see it near the top of its trajectory.

I tried adding the specs for the Nerf dart and a 60cm barrel to my rocket simulator (to get a crude estimate of the effect of air drag), and for 140 kPa I got an estimated max speed of 132m/s and an estimated max height of 52.6m. I don’t know if that height is reasonable—certainly it is better than the no-air-resistance estimate. The 6.78 second estimated time of flight seems to be fairly reasonable, though we never timed it.

Doubling the pressure increases the maximum velocity by a factor of 1.414, but only increases the maximum height to 60.8 m, a 16% increase. Doubling the barrel length has about the same effect. Air drag is what determines the speed of the dart, and that is the least well-modeled part of my simulation.

On Thursday, when they club meets again, they’ll try experimenting with higher pressures, and see whether 17 or 18 msec pulses are long enough—the shorter the pulse the less air will be wasted, and the more shots they can make from the reservoir.  It may be necessary to design a bigger reservoir or add a compressor to the design, since they eventually want a fully automatic Nerf gun, not the one-shot muzzle-loader that they made as the prototype today.  They’ll also start designing a pan-tilt mechanism for the Nerf gun, probably prototyping it out of Lego Technic components.


Filed under: Robotics Tagged: Arduino, Nerf gun, nerf guns, physics, rocket, simulation, SparkFun Electronics
Gas station without pumps 04 Jul 05:12
arduino  nerf gun  physics  robotics  rocket  simulation  sparkfun electronics  

Simple Arduino Serial Communication

This Tutorial is progressive and will be updated from time to time. The goal is to start from a very basic form of Arduino Serial communication, and progressively add or improve components so that we can ultimately transmit data from one computer to another using an XBee.
Please note: I am not an expert, but am happy to share what I have learned. The Arduino forums are a great place to ask questions, feel free to link to this blog (if required).

Let us begin.


Stage 1: ECHO ECHO                                                                                    


Parts Required:

  • Computer
  • USB cable
  • Arduino UNO (or equivalent)
  • Arduino IDE

The following code will make the Arduino ECHO anything you send to it. Therefore, if you type a 3, the Arduino will send back a 3. If you type a letter F, the Arduino will send back a letter F. 
Enter the following code into your Arduino IDE and upload it to your Arduino.


Arduino Sketch


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
/* Simple Serial ECHO script : Written by ScottC 03/07/2012 */

/* Use a variable called byteRead to temporarily store
   the data coming from the computer */
byte byteRead;

void setup() {                
// Turn the Serial Protocol ON
  Serial.begin(9600);
}

void loop() {
   /*  check if data has been sent from the computer: */
  if (Serial.available()) {
    /* read the most recent byte */
    byteRead = Serial.read();
    /*ECHO the value that was read, back to the serial port. */
    Serial.write(byteRead);
  }
}
The above code was formatted using this site


Instructions

1. Once the Arduino sketch has been uploaded to the Arduino. Open the Serial monitor, which looks like a magnifying glass at the top right section of the Arduino IDE. Please note, that you need to keep the USB connected to the Arduino during this process, as the USB cable is your communication link between your computer and the Arduino.



2. Type anything into the top box of the Serial Monitor and press <Enter> on your keyboard. This will send a series of bytes to the Arduino. The Arduino will respond by sending back your typed message in the larger textbox.



3. Please note that we are using Serial.write(byteRead); on line 18 to get the Arduino to ECHO the message back to you on your computer. 



Things to Try 

1. Delete lines 16 to 18, and replace them with the following line :

               Serial.write(Serial.read());

This essentially eliminates the byteRead variable in the sketch above. But we will be using it later on, so once you have tested it out, put the code back together as originally displayed.


--------------------------------------------------------------------
2. Replace line 18 with a Serial.println instead of Serial.write

               Serial.println(byteRead);

Once uploaded, type 1 <enter> 2 <enter> 3 <enter>  into the Serial Monitor.
You should see:

49
50
51

Serial.print and Serial.println will send back the actual ASCII code, whereas Serial.write will send back the actual text. See ASCII codes for more information.


--------------------------------------------------------------------
3. Try typing in numbers like 1.5  or  2.003  or  -15.6 into the Serial Monitor using Serial.write and Serial.print or Serial.println commands as described before.

You will notice that the decimal point transmits as a number using Serial.print  or Serial.println, and will transmit as a decimal point when using Serial.write






STAGE 2: Delimiters                                                                                


How do you handle 2 or more numbers when sending or receiving?
Let us say that you have number pairs that you want the Arduino to interpret. How do you separate the numbers? The answer is Delimiters.
You may be familiar with CSV (comma separated value) files, where each field is separated by a comma (,). The comma is a useful way of separating or grouping information.

Lets say you have the following stream of numbers:
12345678910

How will your Arduino know if this is a single number, or a series of numbers?
Eg:

12,34,56,78,91,0
123,456,78,910
1,2,3,4,5,6,7,8,9,10
12345678910

The comma delimiters help to identify how the numbers should be interpreted.

 In the echo example in Stage 1 above, you would have noticed that when we used Serial.print(byteRead); that the values displayed one after another in a similar fashion to 12345678910.

You would have also noticed that Serial.println(byteRead); provided a line break between each value sent. And depending on the numbers sent, it could have looked like this:
12
34
56
78
91
0

The Serial.println() function essentially uses a line feed to separate the values being sent. This line break can be used as a delimiter, but we will look at that later on. For now we will concentrate on using a comma (,).

We will now get the Arduino to "listen" for the comma to help it identify a new number.
According to the ASCII code site, a comma is equal to byte code 44. So when the Arduino reads a byte code that is equal to 44, we will get it to print a line feed.


Enter the following sketch into your Arduino IDE and upload it to your Arduino.

Arduino Sketch


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
/* Simple Serial ECHO script : Written by ScottC 04/07/2012 */
/* Stage 2 : Delimiters */

/* Use a variable called byteRead to temporarily store
   the data coming from the computer */
byte byteRead;

void setup() {                
// Turn the Serial Protocol ON
  Serial.begin(9600);
}

void loop() {
   /*  check if data has been sent from the computer: */
  if (Serial.available()) {
    /* read the most recent byte */
    byteRead = Serial.read();
    
    /*Listen for a comma which equals byte code # 44 */
    if(byteRead==44){
      Serial.println();
    }else{
      /*ECHO the value that was read, back to the serial port. */
      Serial.write(byteRead);
    }
  }
}
The above code was formatted using this site


Instructions

1. Once the code has been uploaded to the Arduino, open the Serial Monitor once again and type the following sequence of numbers:

1 <enter>  2 <enter> 3 <enter>

You should see the Serial monitor display the following number:    123




--------------------------------------------------------------------
2. While still in the serial monitor, type the following:

, <enter> 1 <enter> , <enter> 2 <enter> , <enter> 3 <enter> ,

Please note the commas between each numerical entry. You should now see a pattern like this:
1
2
3




--------------------------------------------------------------------
3. While still in the serial monitor, type the following:

12,23,34,45, <enter>

Please note the commas between each numerical entry. You should now see a pattern like this:
12
23
34
45

You will notice that the commas have been replaced by line feeds, and each number should display on a new line.



--------------------------------------------------------------------
4. While still in the serial monitor, type the following:

1,,2,,3, <enter>

You should see the following pattern:
1

2

3


So hopefully that explains the concept of delimiters and how they can be used to separate a stream of numbers, no matter how long it takes to get to the Arduino. We used an IF-statement to listen for the comma, but we could have used any other delimiter provided we knew the byte code.

We did not identify how to send delimiters FROM the Arduino, but we will get to that I promise. It is not that hard, and uses a similar principle. I am sure you can work it out, if not, stay tuned.




STAGE 3: Arduino Maths: Simple addition                                                  


In this stage, we are going to get the Arduino to do simple maths. We will send it two integers (or whole numbers), and the Arduino will do the hard work and send us the answer in no time at all.
This might seem like a simple task, but when you send a number like 27 to the Arduino, it does not receive the number 27. It receives 2 and then 7 in byte form. In other words, the Arduino will see the byte codes 50 and then 55 as per the ASCII table on this page.

One way to convert this byte code back to a 2 and a 7 is to subtract 48 from each byte received, providing the byte is in the range 48 to 57 inclusive (which equates to the numbers 0-9).
We are not done yet. We then need to join these numbers to make 27.

Step1: Subtract 48 from the bytes received, only if the bytes are in the range 48 to 57.
                 Example:    50 - 48 = 2
                                    55- 48 = 7

Step2: Multiply the previous number by 10, before adding the most recent byte received.
                 Example:   (2 x 10) + 7 = 27

If we have a number like 1928, then we would create this number using the following calculation
                                   1 =                         1
                   (1 x 10) + 9 =    10 + 9   =   19
                (19 x 10) + 2  = 190 + 2   =  192
              (192 x 10) + 8  = 1920 + 8 = 1928

Step3: Use a "+" sign as a delimiter so that the Arduino can move onto the Second number

Step4:  Capture the second number as per Step2. An "=" sign will tell the Arduino that it has reached the end of the second number, and to proceed to step 5.

Step5:  Add the 2 numbers together and send back the answer.



The following code will carry out the 5 steps above.
Enter the following sketch into your Arduino IDE and upload it to your Arduino.

Arduino Sketch


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
/* Simple Serial ECHO script : Written by ScottC 05/07/2012 */
/* Stage 3: Arduino Maths: Simple Addition */

/* Global variables needed for programming workflow
   byteRead: holds the value being read from the COM port
   num1: holds the entire first number
   num2: holds the entire second number
   answer: holds the sum of num1 and num2
   mySwitch: enables the switch between num1 and num2  */
   
byte byteRead;
long num1, num2,answer;
boolean mySwitch=false;

void setup() {                
/* Turn the Serial Protocol ON and 
   initialise num1 and num2 variables.*/
  Serial.begin(9600);
  num1=0;
  num2=0;
}

void loop() {
   /*  check if data has been sent from the computer: */
  while (Serial.available()) {
    /* read the most recent byte */
    byteRead = Serial.read();
    
    //listen for numbers between 0-9
    if(byteRead>47 && byteRead<58){
       //number found
      
       /* If mySwitch is true, then populate the num1 variable
          otherwise populate the num2 variable*/
       if<!mySwitch)><br  />         num1=(num1*10)+(byteRead-48);<br  />       }<span>else</span>{<br  />         num2=(num2*10)+(byteRead-48);<br  />       }<br  />    }<br  />    <br  />    <span>/*Listen for an equal sign (byte code 61) </span><br  /><span>      to calculate the answer and send it back to the</span><br  /><span>      serial monitor screen*/</span><br  />    <span>if</span>(byteRead==61){<br  />      answer=num1+num2;<br  />      Serial.print(num1);<br  />      Serial.print(<span>"+"</span>);<br  />      Serial.print(num2);<br  />      Serial.print(<span>"="</span>);<br  />      Serial.println(answer);<br  />      <br  />      <span>/* Reset the variables for the next round */</span><br  />      num1=0;<br  />      num2=0;<br  />      mySwitch=<span>false</span>;<br  />      <br  />    <span>/* Listen for the addition sign (byte code 43). This is</span><br  /><span>       used as a delimiter to help define num1 from num2 */</span>  <br  />    }<span>else</span> <span>if</span> (byteRead==43){<br  />      mySwitch=<span>true</span>;<br  />    }<br  />  }<br  />}<br  /></pre></td></tr></tbody></table></div><br  /><span>The above code was formatted using <a href="http://hilite.me/">this site</a></span><br  /><br  /><br  /><h3> <u>Instructions</u></h3><br  /><b>1.</b> Once the code has been uploaded to the Arduino, open the Serial Monitor once again and type the following sequence:<br  /><br  />         <span>1+2=   <enter></span><br  /><br  />You should get the following message sent back to Serial Monitor<br  /><br  />        <span> 1+2=3</span><br  /><br  /><br  /><br  /><h3> <b><u>Things to Try</u></b></h3><b>1.</b>   Enter this sequence: <br  />              <span>10   <enter></span><br  /><span>               +   <enter></span><br  /><span>              10  <enter></span><br  /><span>               =   <enter></span><br  /><br  />       Result:     <span>10+10=20</span><br  /><br  /><span>--------------------------------------------------------------------</span><br  /><b>2. </b>  Enter this sequence:<br  />            <span> 10  <enter></span><br  /><span>             20  <enter></span><br  /><span>             +5= <enter></span><br  /><br  /><br  />      Result:  <span> 1020+5=1025</span><br  /><br  /><br  /><br  /><br  /><span>--------------------------------------------------------------------</span><br  /><b>3.</b>   Enter this sequence:<br  />            <span> 10+20+30=   <enter></span><br  /><br  /><br  />      Result:    <span>10+2030=2040</span><br  /><br  />I have specifically written this script to add <b>two</b> whole numbers together. If you start to introduce more complicated calculations, the results become unpredictable.<br  /><br  /><span>--------------------------------------------------------------------</span><br  /><b>4.</b>    Enter this sequence:<br  />           <span>1.2+1.0=    <enter></span><br  /><br  />      Result: <span>12+10=22</span><br  /><br  />Once again, I have only designed this script to handle whole numbers. Therefore, decimal points are ignored.<br  /><br  /><span>--------------------------------------------------------------------</span><br  /><b>5.</b>  Enter this sequence:<br  />         <span> -5 + 10=     <enter></span><br  /><br  /><br  />     Result:    <span>5+10=15</span><br  /><br  /><br  />This script ignores the negative sign, and treats the -5 as a positive 5.<br  /><br  /><br  /><div>I have done this on purpose. I wanted to show you how the Arduino reads numbers from the com port, and how easy it is to exclude vital functionality in your code. I have kept this script simple, however, if you wanted to, you could make the Arduino deal with each of the above situations and more.  Multiplication, division and subtraction is handled in the same way. </div><br  />This is the last thing I want you to try before we go to the next stage:<br  /><br  />6. Enter this sequence:<br  />           <span>2147483646+1=  <enter></span>           Result:  <span>2147483646+1=2147483647</span><br  />          <span> 2147483647+1=  <enter></span>           Result: <span>2147483647+1=</span><span>-</span><span>2147483648</span><br  /><br  /><br  />Note that the maximum size of a "long" number is 2147483647. If you add one to this number, the result is equal to the minimum size of a "long" which is -2147483648.<br  /><br  /><br  /><br  /><br  /><h3> <b><span><span>STAGE 4:  Sending doubles to Arduino</span> : <span>The double doubler</span>             </span></b></h3><div>Now we get to some tricky business. Sending and receiving Doubles (to and from) the Arduino.<br  /><br  />Up until now, I have tried to keep it simple using whole numbers, but there will come a time when you will want to send a fraction of a number through the Serial line.</div><div>To test our program, we will want to send a very small number to the Arduino, multiply the number by 2, and return it back.</div><div><br  /></div><div>Our final test is to try a number like :  <b>0.000001</b></div><div>             and then a number like:<b>   123.321</b></div><div><br  /></div><div><br  /><b><span>IMPORTANT NOTE</span></b>:   When the Arduino sends a float or a double through the COM port using Serial.print() or Serial.println(), it will automatically send the number to 2 decimal places.<br  />A number like 1.2345 will appear as 1.23,   and a number like 1.9996 will appear as 2.00<br  />To demonstrate this, we will get the Arduino to send these floats/doubles to the Serial Monitor.<br  /><br  /><br  /><div>Enter the following sketch into your Arduino IDE and upload it to your Arduino.</div><div><br  /></div><h3> <u>Arduino Sketch</u></h3><br  /><div><table><tbody><tr><td><pre><span><span> 1<br  /> 2<br  /> 3<br  /> 4<br  /> 5<br  /> 6<br  /> 7<br  /> 8<br  /> 9<br  />10<br  />11<br  />12<br  />13<br  />14<br  />15<br  />16<br  />17<br  />18<br  />19<br  />20<br  />21<br  />22<br  />23<br  />24<br  />25<br  />26<br  />27<br  />28</span></span></pre></td><td><pre><span>/* Stage 4: Simple Transmission of a Double</span><br  /><span>   Written by ScottC on 7/7/2012 */</span><br  /><br  /><span>/* Declare the doubles that will be sent to the Serial Monitor */</span><br  />   <span>double</span> myDub1, myDub2;<br  /><br  /><span>/* This part of the program only runs ONCE */</span><br  /><br  />   <span>void</span> setup(){<br  /><br  />   <span>/* Turn ON Serial Communication */</span><br  />      Serial.begin(9600);<br  />   <br  />   <span>/* Assign a value 1.2345 and 1.9996 to the Doubles being sent */</span><br  />      myDub1=1.2345;<br  />      myDub2=1.9996;<br  />   <br  />   <span>/*Send the values to the Serial Monitor */</span><br  />      Serial.print(<span>"myDub1 (1.2345) : "</span>);<br  />      Serial.println(myDub1);<br  />      Serial.print(<span>"myDub2 (1.9996) : "</span>);<br  />      Serial.println(myDub2);<br  />   }<br  /><br  /><br  />   <span>void</span> loop(){<br  />  <span>//Loop does nothing</span><br  />   }<br  /></pre></td></tr></tbody></table></div><span>The above code was formatted using </span><a href="http://hilite.me/">this site</a><br  /><br  />When you open the Serial monitor (after you have uploaded the sketch above), you will notice the following output:<br  /><br  /><br  />         <span> myDub1 (1.2345) :</span> <span>1.23</span><br  />         <span> myDub2 (1.9996) :</span> <span>2.00</span><br  /><div><br  /></div><br  /><br  />The <span>blue text</span> represents the string (or array of characters) being sent using lines 19 and 21.<br  />The <span>red text</span> represents the actual double being sent using lines 20 and 22.<br  /><br  />You will notice that myDub2 rounds to 2.00.  This may or may not be what you want.<br  />If you wish to increase the number of decimal places, then you will need to change lines 20 and 22 to the following:<br  /><br  /><span><span>20         Serial.println(myDub1,</span><span>4</span><span>)</span>;</span><br  /><span><span>22         Serial.println(myDub2,</span><span>4</span><span>);</span></span><br  /><br  />The number 4 highlighted in red, indicates the number of decimal places you wish to send.<br  />Try it ! And try changing this number to something bigger or smaller.<br  /><br  />---------------------------------------------------------------------------------------------------<br  />Ok - now that we understand this little Serial.print(double,decimals) trick, we will now get the Arduino to echo back a Double.<br  /><br  />Before we jump in, perhaps we should try and map out our strategy. For this we will choose a simple decimal to make it easier. So in this example, we will choose <b>0.1</b></div><div>Once we get this working, we can then do our final test (as mentioned above).</div><div><br  /></div><div>If we send 0.1 to the Arduino, it will read the following byte code</div><div><br  /></div><div>48                    0</div><div>46                    .</div><div>49                    1</div><div><br  /></div><div>We can use the decimal point as a delimiter.<br  />We will use the following 5 steps to echo the double back to the Serial Monitor:</div><div><br  /></div><div><b><span>Step1</span>:</b> Arduino collects all numbers before the decimal point using the same technique as in Stage3.<br  /><br  /></div><div><b><span>Step2</span>: </b>When the Arduino receives byte code 46, it will go into decimal mode.<br  /><br  /></div><div><b><span>Step3</span>:</b> The Arduino will collect numbers after the decimal point using a similar technique to step1.<br  /><br  /></div><div><b><span>Step4</span>:</b> Use maths to create the double, and then multiply it by 2<br  /><br  /></div><div><b><span>Step5</span>:</b> Display the doubled Double value in the Serial monitor.</div><div><br  /></div><div><br  /></div><div><br  /><div>Enter the following sketch into your Arduino IDE and upload it to your Arduino.</div><div><br  /></div><h3> <u>Arduino Sketch</u></h3></div><div><br  /></div><div><table><tbody><tr><td><pre><span><span> 1<br  /> 2<br  /> 3<br  /> 4<br  /> 5<br  /> 6<br  /> 7<br  /> 8<br  /> 9<br  />10<br  />11<br  />12<br  />13<br  />14<br  />15<br  />16<br  />17<br  />18<br  />19<br  />20<br  />21<br  />22<br  />23<br  />24<br  />25<br  />26<br  />27<br  />28<br  />29<br  />30<br  />31<br  />32<br  />33<br  />34<br  />35<br  />36<br  />37<br  />38<br  />39<br  />40<br  />41<br  />42<br  />43<br  />44<br  />45<br  />46<br  />47<br  />48<br  />49<br  />50<br  />51<br  />52<br  />53<br  />54<br  />55<br  />56<br  />57<br  />58<br  />59<br  />60<br  />61<br  />62<br  />63<br  />64<br  />65<br  />66<br  />67<br  />68<br  />69<br  />70<br  />71<br  />72<br  />73<br  />74<br  />75<br  />76<br  />77<br  />78<br  />79<br  />80<br  />81<br  />82<br  />83<br  />84<br  />85</span></span></pre></td><td><pre><span>/* Simple Serial ECHO script : Written by ScottC 06/07/2012 */</span><br  /><span>/* Stage 4: Double doubler */</span><br  /><br  /><span>/* Global variables needed for programming workflow</span><br  /><span>   ------------------------------------------------------</span><br  /><span>   byteRead: holds the value being read from the COM port</span><br  /><span>   num1: holds the number before the decimal point</span><br  /><span>   num2: holds the number after the decimal point</span><br  /><span>   complNum: holds the complete number (before multiplation)</span><br  /><span>   answer: holds the final value after multiplication</span><br  /><span>   counter: is used to convert num2 to the number after the decimal</span><br  /><span>   numOfDec: counts the numbers after the decimal point</span><br  /><span>   mySwitch: enables the switch between num1 and num2  */</span><br  />   <br  />   byte byteRead;<br  />   <span>double</span> num1, num2;<br  />   <span>double</span> complNum,answer,counter;<br  />   <span>int</span> numOfDec;<br  />   boolean mySwitch=<span>false</span>;<br  /><br  /><br  />   <span>void</span> setup() {                <br  /><span>/* Turn the Serial Protocol ON and </span><br  /><span>   initialise num1 and num2 variables.*/</span><br  />     Serial.begin(9600);<br  />     num1=0;<br  />     num2=0;<br  />     complNum=0;<br  />     counter=1;<br  />     numOfDec=0;<br  />   }<br  /><br  />   <span>void</span> loop() {<br  /><span>/*  check if data has been sent from the computer: */</span><br  />     <span>while</span> (Serial.available()) {<br  />     <span>/* read the most recent byte */</span><br  />        byteRead = Serial.read();<br  />    <br  />       <span>//listen for numbers between 0-9</span><br  />       <span>if</span>(byteRead>47 && byteRead<58){<br  />          <span>//number found</span><br  />      <br  />          <span>/* If mySwitch is true, then populate the num1 variable</span><br  /><span>          otherwise populate the num2 variable*/</span><br  />          <span>if</span><!mySwitch)><br  />            num1=(num1*10)+(byteRead-48);<br  />          }<span>else</span>{<br  />            num2=(num2*10)+(byteRead-48);<br  />         <br  />         <span>/* These counters are important */</span><br  />            counter=counter*10;<br  />            numOfDec++;<br  />          }<br  />       }<br  />    <br  />    <span>/*Listen for an equal sign (byte code 61) </span><br  /><span>      to calculate the answer and send it back to the</span><br  /><span>      serial monitor screen*/</span><br  />      <span>if</span>(byteRead==61){<br  />   <span>/* Create the double from num1 and num2 */</span><br  />      complNum=num1+(num2/(counter));<br  />      <br  />   <span>/* Multiply the double by 2 */</span>   <br  />      answer=complNum*2;<br  />      <br  />   <span>/* Send the result to the Serial Monitor */</span>   <br  />      Serial.print(complNum,numOfDec);<br  />      Serial.print(<span>" x 2 = "</span>);<br  />      Serial.println(answer,numOfDec);<br  />      <br  />   <span>/* Reset the variables for the next round */</span><br  />      num1=0;<br  />      num2=0;<br  />      complNum=0;<br  />      counter=1;<br  />      mySwitch=<span>false</span>;<br  />      numOfDec=0;<br  />      <br  />  <span>/* Listen for the decimal point (byte code 46). This is</span><br  /><span>     used as a delimiter to help define num1 from num2 */</span>  <br  />     }<span>else</span> <span>if</span> (byteRead==46){<br  />        mySwitch=<span>true</span>;<br  />     }<br  />   }<br  /> }<br  /></pre></td></tr></tbody></table></div><div><span>The above code was formatted using </span><a href="http://hilite.me/">this site</a></div><div><br  /></div><div><br  /></div><div><br  /><h3> <b><u>Things to Try</u></b></h3><div><b><u><br  /></u></b></div><div>1. Type the following into the serial monitor:</div><div><br  /></div><div>       <span>1.2=  <enter></span>                             Result:   <span>1.2 x 2 = 2.4</span></div><div><br  /></div><div>Make sure that you type the equal sign (=) before you press enter, otherwise the Arduino will not know that you are finished, and will not send anything back.</div><div><br  /></div><div>--------------------------------------------------------------------</div><div>2. Type the following into the serial monitor:</div><div><br  /></div><div>      <span>100.001=  <enter></span>                      Result:   <span>100.001 x 2 = 200.002</span></div><div><br  /></div><div>You will notice that the Arduino is formatting the decimal to the SAME number of decimals as that entered.</div><div>This is controlled by the variable: <span>numOfDec</span>.</div><div>---------------------------------------------------------------------</div><div>3. Now for our final test: Type the following into the serial monitor:</div><div><br  /></div><div>   <span> 0.000001= <enter></span>                       Result: <span>0.000001 x 2 = 0.000002</span></div><div><br  /></div><div>First test:<span> PASSED</span></div><div><br  /></div><div>----------------------------------------------------------------------</div><div>4. Type the following into the Serial monitor for our last test:</div><div><br  /></div><div>     <span>123.321=  <enter></span>                      Result: <span>123.321 x 2 = 246.642</span></div><div><br  /></div><div>Second test: <span>PASSED</span></div><div>-----------------------------------------------------------------------</div><div><br  /></div><div><span>BEWARE</span>: While everything looks perfect, let me tell you that it isn't. But hopefully this code will help you get on the right track. If you decide to type in a number like 123123.111222, you will not get the answer you expected. </div><div>I have found that this program will work if the amount of numbers before and after the decimal point are less than about 9.  Eg. 1234.1234   will produce the right result.</div><div>However, 11111.2222 will NOT, because there are 9 numbers represented.</div><div><br  /></div><div>I think this has something to do with the memory allocated to a double, but I am not sure. </div><div>I don't know if people work with these types of numbers, but I am sure there is a workaround, and I am sure someone out there can work it out. I don't personally need this kind of precision, but thought to mention it just in case you do.</div><div><br  /></div><div><br  />----------------------------------------------------------------------- <br  />----------------------------------------------------------------------- <br  /><br  /><h3> <b><span><span>STAGE 5:  Sending sensor data to the Serial Monitor</span>             </span></b></h3><br  /><br  />We know the Arduino is very good at copy-Cat games, how about getting the Arduino to send us some data from one of our sensors. We will use the Serial Monitor to view the sensor data.<br  /><br  />Disconnect the USB cable, and hook up one of your favourite analog sensors to your Arduino. For simplicity, I am going to hook up a potentiometer as per the Fritzing sketch below.<br  /><br  /><h3> <u> Parts Required</u></h3><br  /><ul><li>Arduino UNO (or equivalent)</li><li>Computer with USB cable</li><li>Breadboard</li><li>Potentiometer</li><li>3 Wires</li></ul><div><br  /></div><br  /><h3> <u> Arduino Fritzing Sketch</u></h3><br  /></div><div><div><a href="http://1.bp.blogspot.com/-JZlWUi3MDck/T_g6ldkqSVI/AAAAAAAAAPY/_UJj4EU3YYE/s1600/Fritzing_Potentiometer_Sketch.jpg"><img src="http://1.bp.blogspot.com/-JZlWUi3MDck/T_g6ldkqSVI/AAAAAAAAAPY/_UJj4EU3YYE/s400/Fritzing_Potentiometer_Sketch.jpg"  /></a></div><br  /></div><div><br  /></div><div>     </div><div><br  /></div><div><br  /></div></div><br  /><br  /><br  /><br  /><br  /><br  /><br  /><br  /><br  /><br  /><br  /><br  /><br  /><br  /><br  /><br  /><br  />Once you have attached your sensor to the board, plug your USB cable into the Arduino, and upload the following sketch.<br  /><br  /><br  /><h3> <u>Arduino Sketch</u></h3><div><u><br  /></u></div><div><table><tbody><tr><td><pre><span><span> 1<br  /> 2<br  /> 3<br  /> 4<br  /> 5<br  /> 6<br  /> 7<br  /> 8<br  /> 9<br  />10<br  />11<br  />12<br  />13<br  />14<br  />15<br  />16<br  />17<br  />18<br  />19<br  />20<br  />21</span></span></pre></td><td><pre>  <span>/* Stage 5: Send Sensor Value to Serial Monitor</span><br  /><span>     Written by ScottC on 7/7/2012 */</span><br  /><br  />  <span>int</span> sensorVal = 0;  <br  /><br  />  <span>void</span> setup() {<br  /> <span>// Setup Serial communication with computer</span><br  />    Serial.begin(9600);<br  />  }<br  /><br  />  <span>void</span> loop() {<br  /> <span>// Read the value from the sensor:</span><br  />    sensorVal = analogRead(A0);<br  /> <br  /> <span>// Send the value to the Serial Monitor</span><br  />    Serial.print(<span>"Sensor Value="</span>);<br  />    Serial.println(sensorVal);<br  /><br  /> <span>// Interval between readings = 1 second</span><br  />    delay(1000);                <br  />  }<br  /></pre></td></tr></tbody></table></div><div><span>The above code was formatted using </span><a href="http://hilite.me/">this site</a><br  /><u><br  /></u><br  /><u><br  /></u><br  /><h3> <u>Instructions</u></h3></div></div></div><div>1. Open the Serial monitor and watch the readings change depending on the input conditions. In my case, by turning the potentiometer from left to right, I get an output similar to the picture below.</div><div><br  /></div><div><a href="http://2.bp.blogspot.com/-F8H8h8YkXJo/T_g_dcPTN1I/AAAAAAAAAPk/AXQaR5x_UFk/s1600/Serial+Monitor.jpg"><img src="http://2.bp.blogspot.com/-F8H8h8YkXJo/T_g_dcPTN1I/AAAAAAAAAPk/AXQaR5x_UFk/s400/Serial+Monitor.jpg"  /></a></div><div><br  /></div><div><br  /></div><div><br  /></div><div><br  /></div><div><br  /></div><div><br  /></div><div><br  /></div><div><br  /></div><div><br  /></div><div><br  /></div><div><br  /></div><div><br  /></div><div><br  /></div><div><br  /></div><div><br  /></div><div><br  /></div><div><br  /></div><div><br  /></div><div><br  /></div><div>As per the Arduino reference site, <a href="http://arduino.cc/en/Reference/analogRead">AnalogRead</a> returns an integer between 0 and 1023. You can see this is true based on the picture above. But what if we do not want a value between 0 and 1023. Let us say we want a value between 0 and 100?</div><div><br  /></div><div>You would have to use the <a href="http://arduino.cc/en/Reference/Map">map function</a>. We will do it by changing line 13 to this:</div><div><br  /></div><div><pre><span><span>13</span></span><span>  </span><span><span><b>sensorVal = map(analogRead(A0),0,1023,0,100);</b></span></span></pre></div><div><br  /></div><div>The map function is quite a cool function, and good fun to play around with. So here are some things to try.</div><div><h3> <b><u>Things to Try</u></b></h3></div><div>1. Change line 13 to the following, upload to the Arduino </div><div>    and then open the Serial Monitor to see the effect.</div><div><br  /></div><div><b><span>Trial 1</span></b>:</div><div><pre><span><span>13</span></span><span>  </span><span><span><b>sensorVal = map(analogRead(A0),0,1023,100,0);</b></span></span></pre></div><div><br  /></div><div><div><b><span>Trial 2</span></b>:</div><div><pre><span><span>13</span></span><span>  </span><span><span><b>sensorVal = map(analogRead(A0),0,1023,0,1000);</b></span></span></pre></div></div><div><br  /></div><div><div><span><b>Trial 3</b></span>:</div><div><pre><span><span>13</span></span><span>  </span><span><span><b>sensorVal = map(analogRead(A0),200,800,0,100);</b></span></span></pre></div></div><div><br  /></div><div><br  /></div><div>In <b><span>Trial 1</span></b>: We see that the values have been inverted. Instead of ranging from 0 up to100, they now go from 100 down to 0.</div><div><br  /></div><div>In <b><span>Trial 2</span></b>: The analog readings are now mapped to a range of 0 up to 1000. </div><div><br  /></div><div>In <b><span>Trial 3</span></b>: The analog readings that range from 200 to 800 are mapped to a range of 0 to 100. Therefore if the analog readings drop below 200, we will end up with a negative value for sensorVal. </div><div>If the analog readings go above 800, we will end up with a value greater than 100.  For this particular example, my readings actually range from  -33 to 137.</div><div><br  /></div><div>Therefore an Analog reading of 0 = -33</div><div>                 Analog reading of 200 = 0</div><div>                 Analog reading of 800 = 100</div><div>               Analog reading of 1023 = 137</div><div><br  /></div><div><br  /></div><div>----------------------------------------------------------------------------------</div><div>What if we don't want the output to go beyond our intended limits of 0 to 100?</div><div>Then you would have to use the <a href="http://arduino.cc/en/Reference/Constrain">constrain function</a>. This essentially trims the reading range of the sensor, and sets a minimum and maximum value.</div><div><br  /></div><div>Replace line 13 with the following code:</div><div><br  /></div><div><pre><span><span>13</span></span><span>  </span><span><span><b>sensorVal = constrain(map(analogRead(A0),200,800,0,100),0,100);</b></span></span></pre></div><div><br  /></div><div><div>Therefore an Analog reading of 0 = 0</div><div>                 Analog reading of 100 = 0</div><div>                 Analog reading of 200 = 0</div><div>                 Analog reading of 800 = 100</div><div>                  Analog reading of 955 = 100</div><div>               Analog reading of 1023 = 100</div></div><div>Analog values between 200 and 800 will produce a result between 0 and 100.</div><div><br  /></div><div>-------------------------------------------------------------------------------------<br  /><br  /><h3><span>If you wish to continue with this tutorial (stage 6 and above), please follow this link:  <a href="http://arduinobasics.blogspot.com/2012/07/arduino-basics-simple-arduino-serial_09.html">Serial Communication Stage 6 and above</a> </span></h3></div><div><br  /></div><div><br  /></div> <br  />   <br  />   <div> <p> <!--separator --> <img src="https://images-blogger-opensocial.googleusercontent.com/gadgets/proxy?url=http%3A%2F%2F1.bp.blogspot.com%2F-XQiwNpdqOxk%2FT_rKCzDh4nI%2FAAAAAAAAAQY%2FOfYBljhU6Lk%2Fs1600%2FSeparator.jpg&container=blogger&gadget=a&rewriteMime=image%2F*"  /><br  /> <br  /> </p> </div> <p> <div> <p>   If you like this page, please do me a favour and show your appreciation : <br  /> <br  />     <br  />   Visit my <a href="https://plus.google.com/u/0/b/107402020974762902161/107402020974762902161/posts">ArduinoBasics Google + page</a>.<br  />   Follow me on Twitter by looking for <a href="https://twitter.com/ArduinoBasics">ScottC @ArduinoBasics</a>.<br  />   I can also be found on <a href="https://www.pinterest.com/ArduinoBasics/">Pinterest</a> and <a href="https://instagram.com/arduinobasics">Instagram</a>. <br  />   Have a look at my videos on my <a href="https://www.youtube.com/user/ScottCMe/videos">YouTube channel</a>.<br  /> </p></div> <div> <p>               <a href="http://arduinobasics.blogspot.com.au/p/arduino-basics-projects-page.html"><img src="http://2.bp.blogspot.com/-4b59S-y-Tws/VYeJtC1HNyI/AAAAAAAABk4/_CWyTKOPYOw/s320/ArduinoBasics_OpenLogo%2Bon%2BBlack.png"  /></a> </p></div> <div> <p> <img src="https://images-blogger-opensocial.googleusercontent.com/gadgets/proxy?url=http%3A%2F%2F1.bp.blogspot.com%2F-XQiwNpdqOxk%2FT_rKCzDh4nI%2FAAAAAAAAAQY%2FOfYBljhU6Lk%2Fs1600%2FSeparator.jpg&container=blogger&gadget=a&rewriteMime=image%2F*"  /><br  /> <br  /> </p></div> <div> <p>  However, if you do not have a google profile... <br  />Feel free to share this page with your friends in any way you see fit.  </p></div></p>
ScottC 03 Jul 17:40
addition  analogread  arduino  arduinobasics  best arduino blog  code  comma  communication  constrain  delimiters  double  echo  floats  map  precision  serial  serial monitor  usb  

Noise pollution tit for tat uses the Baha Boys as a weapon

Here [Matthew Br] explains the situation he’s in with the neighbors that share this wall of his apartment. When they listen to music they like it loud and so he gets to ‘enjoy’ the experience as well. But he can’t ignore it any longer, and has decided to use a sound volume detector to blast some tunes right back at them.

He taped a microphone to the wall and wired it up to his Arduino. It monitors incoming sound and, using an adjustable threshold, it will trigger when the neighbors are too loud. We think he was wise to include some time filtering that makes sure the loud noises are sustained and not just the result of someone bumping into the wall. When the system does detect loud music for a sustained period it triggers [Matthew's] own CD player to pump out Who Let the Dogs Out? by the Baha Boys. It will play for a period of time, then shut off to listen and see if the neighbors are still rowdy.

He documents an actual run in the latter half of the clip after the break. We sure hope he’s living in a building with just two units, otherwise this will drive the rest of the neighbors batty as well!


Filed under: digital audio hacks
Hack a Day 03 Jul 16:02
apartment  arduino  baha boys  digital audio hacks  neighbors  noise  

Codebender: An online Arduino IDE

Because everything is moving to a web app, [Vasilis Georgitzikis], a.k.a. [tzikis] developed codebender, a cloud-based Arduino IDE replete with built-in libraries, documentation, and the ability to upload your code to an Arduino from a browser.

To compile an Arduino sketch, codebender uses clang a wonderful compiler that will give you extremely descriptive warnings on terrible code. Like any good IDE, there’s built-in highlighting and documentation, and a small bit of Java allows you to upload your code and monitor the serial port right in the browser.

One of the more interesting innovations is codebender’s (upcoming) use of a TFTP bootloader. With this and an Ethernet shield, it’s easy to upload code to any Internet-connected Arduino, whether it’s on your desk or halfway across the world. We can see that being very useful for a data logger or even a UAV balloon, and can’t wait to see it in action.


Filed under: arduino hacks
Hack a Day 01 Jul 21:16
arduino  arduino hacks  codebender  ide  

QRD1114 Resistor Values

Hi all,

I'm using a QRD1114 sensor for a line-follower. Datasheet: http://www.fairchildsemi.com/ds/QR/QRD1114.pdf

Im hooking it up with this schematic:

However, I'm unsure how the value for the 10K resistor was calculated? It's acting as a potential divider, right?

For the LED im guessing that the value of 220 was taken from doing:

R=(Input Voltage - Max Forward Voltage)/(Optimum forward current)

read more

Let's Make Robots 01 Jul 21:05
absolute beginners  arduino  current  divider  follower  following  limiting  line  potential  qrd1114  resistor  voltage  

Audio VU meter (AC microVoltmeter) with Extra wide Dynamic Range 69 dB.

O’K, after having some fun with stereo version of the VU meter I described in my previous blog-post, now it’s time to do a serious stuff. Studio grade VU meter !!! 24 steps, equally spaced every 3 dB, covering Extra wide Dynamic Range from -63  up to  +6 dB.  Single (mono) channel this time, no messing around, absolute precision at the stake. Plus, it keeps absolutely Top-Flat linear frequency response from 40 Hz up to 20 kHz(*).

 

 

I’m not going into details of RGB LEDs Display, which has no modification since “Tears of Rainbow” project, only plates installed in one line, form a single GIGANTIC bar-graph. There are some minor changes in mixing colors data tables, but they intuitively understandable.  The most important feature in this project is autoscaling. As you, probably know, Arduino has 10 bits ADC. Only it can’t process negative half-wave, and for this reason it has only 9 bits available for AC measurements.  According to DSP theory, maximum dynamic range is:

DR = 1.77 + 6.02 x B = 1.77 + 6.02 x 9 = 55.95 dB.

 As input audio waveform represents anything but perfect peak-to-peak 5V sine-wave, real dynamic range would be lower. How much? In first, there is a hardware limits.  OPA (NE5532), which is:

  • very low noise !!!
  •  high output-drive capability;
  •  high unity-gain and maximum-output-swing bandwidths;
  •  low distortion;
  •  high slew rate;
  •  input-protection diodes, and output short-circuit protection

 but, unfortunately,  isn’t rail-to-rail type. Test results show, that compression  become noticeable (~1 dB) when not scaled magnitude approaches level about 50 dB. That is in good agreement with observed on oscilloscope not distorted deviation peak-to-peak 2.5 V. Or only half of full range of 5V. And as theory says, half is one bit less, and real DR = 1.77 + 6.02 x 8 = 49.93  (~50 dB). In second, audio data is processed on “block” structure basis. It means, having average of the block 50 dB, doesn’t mean that there was no spikes in the sampling pull, that obviously would be clipped and introduce error in the measurements results.  This phenomenon is defined as Crest Factor. Different sources estimate crest factor of musical content between 10 – 20 dB.  So, taking direct approach, Arduino with OPA mentioned above as front-end could accurately cover only:              50 – 20 = 30 dB.  To get wider dynamic range, I have to scale input amplifier gain, and this is exactly what I did, building amplifier in two stages and selecting one cascade (by-passing second one) or two cascades using internal ADC multiplexer. As there is no switching IC in analog signal path involved, gain is defined with high stability, could be one time precisely measured – calibrated via coefficient stored in EEPROM (nice feature to add).

On the right side there are electrical drawings of “slightly” modified kit,  where stereo amplifier was converted into 2 stage mono version. First stage, with gain about  G1 = 1 + 10 k / 1 k = 11  is necessary to “bump-up” line-level signal, to create DC bias required for correct operation of the ADC, and also served as buffer to lower signal source impedance, as it seen by ADC input.  I set a gain of the second stage amplifier at 40 dB:  20 x Log_10 ( G2 ),     where    G2 = 1 + 100 k / 1 k = 101.

IMHO, setting gain limit for only 30 db per stage as it follows from paragraph above, is overkill, and would be justified for “real-time” radio broadcasting or audio processing for storage media, when high fidelity of audio program must be preserved. For visual display “clipping” of bursts in signal is not noticeable at all due high refresh rate of display, 78 Hz. Human just can’t see, if LED lights-up with such speed.  For steady AC amplitude measurements (micro Voltmeter mode) this is not a problem at all, and headroom as small as 3 dB would be sufficient, leaving wide 47 dB per stage.

 Software

  There are two thresholds are defined in program, where switching between one or two stage amplification is happening:

      if ( magn_new <=  44 ) sensitv = 1;

      if ( magn_new >= 47 ) sensitv = 0;

  44 and 47, with hysteresis 3 dB. First line defines switching to high sensitive mode (overall gain 1100), and second line, does exactly opposite. Look at the chart, hope it would save me a million words -);

 Couple words on using this device as precise AC micro-voltmeter. Having 1100 overall amplification as add-up to already quite sensitive Arduino ADC, driving overall sensitivity to enormously  5 / ( 1024 x 1100 ) = 4.439 uV Special care should be taken on grounding, shielding of amplifier PCB, probably, EMI suppressor ferrite chokes wouldn’t be an excess in power line and signal path.   In my project, w/o any modification to original kit’s board (except couple jumper wires to cascade two stage amplifier) of course, I was not expecting to get to such high sensitivity level. Moreover, in project arduino is driving LED display, “ADC noise reduction mode” is off, plus ADC is working on double speed – preselector set to 250 kHz!!!  And this is why constant 14 was subtracted in software from magn_new, just before it goes for BarGraph “mapping” procedure:

      magn_new  -= 14;

Basically 14 is a noise flour of my analog front-end.  Approximately 51 micro volts AC is turning on first LED bar. Look at the table, which reflect my current hardware set-up.

* Other things to keep in mind, there is a “gap” 78 Hz wide in frequency range at 10 kHz,  It introduces a small error, about  78 / 20.000 = 0.39% in white noise measurements result. For musical content, which has really low power density level at 10 kHz, magnitude of error would be much lower, probably, less than 0.05 %.

 Running FFT in code creates great opportunity to reject any interference in the audio band. For example, if there is a noticeable hum from electrical grid lines in the content, issue easily could be fixed NOT including bin[1] in final sum of magnitude calculation. Though to make it works more efficient, some adjustment in sampling period would be necessary, setting bin[1] frequency precisely at 50/60 Hz.

 One more advantage of having FFT based  filtering     (primary mission is HPF, look in stereo VU meter, how long kernel of the FIR filter has to be otherwise), is great opportunity to create “weighting” A, B, C or D curve for audio noise measurements. (:TO DO).

 Link to Download Arduino sketch:  Audio_VU_Meter_Mono_69dB


coolarduino 01 Jul 16:05
20 khz.  ac microvoltmeter  arduino  audio.  c code  download  fft  fixed point  integer  millivoltmeter  peak program meter ppm  radix-4  real time  rgb led display  true rms  uncategorized  vu meter  

Lets Make Robots or Lets Make Radars?

A while back I notice the simularity between the Ultrasound/IR sensors we use on robots for object avoidance to the concept of basic RADAR. (This is more like UDAR or IRDAR). Direction and range information are what the controller uses to detect objects (RADARs basically use the same information.)

So instead of building robots for a while I decided to see how good I could make my own IRDAR. Wow! One can adjust trigger point, gain and a bunch of other factors and have a way-cool little system!

read more

Let's Make Robots 01 Jul 00:38
arduino  avr  non-robot  pic32  uno32