How To: Arduino to Parallax Serial Terminal
Well folks, I finally got around to doing this...
Posts with «serial» label
A custom Pi shield or an Arduino?
As more and more people get a Pi they are asking how to interface it to their robot. I do not own a Pi but I looked at the GPIO pins available for interfacing. Apart from general digital I/O pins you have I2C, SPI and Serial interfacing available. I assume there is a library or something that allows these pins to be easily access from within the Linux operating system.
So the question becomes do you just use another MCU such as an Arduino to provide the necessary I/O functionality or do you use a custom shield?
Quasi real-time oscilloscope: REMIX
Updated on 21 Sept. 2012, version 4.
Updated on 15 Oct. 2012, version 5.
Recently I was reviewing one of my oldest project, and decided to “refresh” previous design by taking full advantage of the new arduino Leonardo board. Based on AtMega32U4, which include PGA (programmable gain amplifier), oscilloscope’s analog front end doesn’t require external OPA this time, end could be build in 1-2 hours on prototype board, using 5 resistors, 5 capacitors and one IC. Short specification:
- Four channels.
- Switchable gain settings 1x, 10x, 40x, 200x.
Hardware.
As you can see on drawings above, inputs are AC coupled with caps, and biased with 1.25V generated by LM317. Connector for other two inputs not installed yet.
Software.
Project keeps almost same structure of commands (CLI – command line interface) as its ancestor, with only two new for channel and gain selection. Read comments, it explains how to use them. One more things, I removed “r” – re-print option from the list of available commands.
Have fun!.
Link to arduino Leonardo sketch: Oscilloscope_Leonardo.
********************************************* Version 4*********************************************
Well, even posted above sketch has low complexity, and its good for beginning, nevertheless it’s quite limited as measuring device. The most important feature for oscilloscope, except V/div, is T/div, or timing, that has to be as much precise as possible. This is why “standard” timing options based on TIMER1 were add to next version of software. There are 9 time settings Time/div (10 samples):
50ms, 20ms, 10ms, 5ms, 2ms, 1ms, 500us, 200us, 100usec
corresponding to
200Hz, 500Hz, 1kHz, 2kHz, 5kHz, 10kHz, 20kHz, 50kHz, 100kHz
sampling rate. You can choose any of of this in the same manner, entering a digit 1-9 and letter d (display). Zero would skip capture, and just do whatever next letter request. Basically, 0 should be used to print channels data from memory. Combination: 9d0i – capture at 100 kHz rate, print chart and info-table,
4c2g7d – select 4-th channel, set gain to 10, select 20 kHz sampling rate and display.
I also add multichannel sampling capability. Commands 2m, 3m or 4m would configure oscilloscope for 2, 3 or 4 channels simultaneously capturing input waveform. As arduino has only 1 ADC, switching in multichannel mode would reduce sampling rate proportionally to number of channels, and this changes would be reflected in right top corner of the display. What more, arduino would automatically change vertical resolution per channel, to fit all 2 – 4 charts on one screen!
Known caveats:
- Sampling rate 9, or 100 usec per division (10 usec per sample) could not be selected in multichannel mode, should be in use for single channel only (1m, 1c – 2c – 3c – 4c).
- There is a “shift” in channel number, signal presented at input 1 would show up on screen 2, and so on. This happens on time settings 7 (occasionally), 8 and 9 in 4x multichannel mode due delay in MUX registers switching. Shouldn’t be an issue for 2x channel mode, or when you have an “overview” of the signals shape in single channel mode (1m) before switching to 4x, so you would know what to expect at each input port.
Link to arduino Leonardo sketch: Oscilloscope_LeonardoV4
********************************************* Version 5*********************************************
New updated version. I was thinking how to improve simplest ever oscilloscope, and have made some structural changes in the code, mostly related to sampling in multichannel mode.
First of all, instead of “delay” 2 microseconds, that was used to give a multiplexer (and PGA amplifier) time to “settle” on new channel, I decided not to waste a time (that may be priceless in real-time application), rather start new conversion, than track samples based on the “history” of MUX settings, and store new sample in corresponding two dimensional array box. Now MUX and PGA would have more time, and consequently I could reduce ADC pre-selector’s clock to get better readings. It solved all the problems with wrong association port number and picture on the screen.
Secondly, as you, probably, already notice I’ve been working on another project recently, where phase is a PRIME factor of the whole idea of the design. Phase noise is a jitter, and it degrades spatial resolution and the sensitivity of the sound localization. Jitter always would be presented in the incoming signal – sampled waveform due “not synchronous” way of sampling, as “start new conversion” events were generated in “manual” mode. As microprocessor spend different amount of time to get inside of the ISR (interrupt subroutine) depends on where it was interrupted, time frame of the events, basically, was not defined. In order to get rid off the phase noise, I changed ADC settings to be triggered via TIMER 1. There is a code:
ADCSRA = ((1<< ADEN)| // 1 = ADC Enable
(0<< ADSC)| // 1 = ADC Start Conversion
(1 <<ADATE) | / / 1 = ADC Auto Trigger Enable
*****
ADCSRB = ((1<<ADHSM)| // High Speed mode select
(0<< MUX5)| // 0 (10100) ADC1<->ADC4 Gain = 1x.
(0<<ADTS3)|
(1 <<ADTS2) | / / Sets Auto Trigger source Timer/Counter1 Compare Match B
(0 <<ADTS1) |
(1 <<ADTS0) );
For some unknown for me reason, Atmel designed TIMER 1 channel B to be an auto trigger source of the ADC, the same time to run TIMER 1 itself in CTC mode, channel A must be set. I simply “bind” two channels A and B in “parallel”, so both of them rise interrupt flag at the same moment, only A re-starts a TIMER 1, and B generates “start new conversion” event and calling ISR for “maintenance” – take a new sample waiting in the line and switch a MUX to another channel of the oscilloscope.
uint8_t take_it( int fast )
{
ADCSRA &= 0xF8;
if ( multChan -1 )
{
switch( fast ) {
case 7: // 20 kHz /
ADCSRA |= 0×03;
break;
case 8: // 50 kHz /
ADCSRA |= 0×02;
break;
case 9: // 100 kHz /
Serial.print(F(“\n\t *** NOT SUPPORTED ***”));
return 0;
default:
ADCSRA |= 0×04;
}
}
else
{
switch( fast ) {
case 6: // 10 kHz /
ADCSRA |= 0×06;
break;
case 7: // 20 kHz /
ADCSRA |= 0×05;
break;
case 8: // 50 kHz /
ADCSRA |= 0×04;
break;
case 9: // 100 kHz /
ADCSRA |= 0×03;
break;
default:
ADCSRA |= 0×07;
}
}
OCR1A = smplTime[fast -1];
OCR1B = smplTime[fast -1];
TCNT1 = 0;
TIFR1 |= (1<<OCF1B);
TIMSK1 |= (1<<OCIE1B);
flagSamp = 0;
while ( !flagSamp );
for ( uint8_t indx, y = 0; y < multChan; y++){
if ( multChan -1) indx = y;
else indx = chanNumb;
for ( int i = 0; i < INBUF; i++){
if ( x[indx][i] & 0×0200) x[indx][i] += 0xFE00; // Convert to negative 16-bit word (2′s comp)
else x[indx][i] += 0×200;
}
}
return 1;
}
ISR(TIMER1_COMPB_vect)
{
static uint8_t n_sampl = 0;
static uint8_t history = 0;
x[history][n_sampl] = ADC;
history = chanNumb;
if ( multChan -1 )
{
chanNumb++;
if ( chanNumb >= multChan )
{
chanNumb = 0;
n_sampl++;
}
ADMUX &= 0xFC;
ADMUX |= chanNumb;
}
else
{
n_sampl++;
}
if ( n_sampl >= INBUF )
{
flagSamp = 1;
n_sampl = 0;
TIMSK1 &= ~(1<<OCIE1B);
}
}
The only issue that not solved yet, is a sampling in multichannel mode in “9″ T/div. Probably, Atmel just was not design to do such things…
Simple Arduino Serial Communication (Part 2)
In Stages 1 to 5 , we experimented with the Serial Monitor on the Arduino IDE to transmit data to the Arduino and receive data from the Arduino. We performed simple Serial communication of data in both directions.
We then moved from transmitting a String of characters to the more difficult task of transmitting a double or a float.
Finally, we used the Serial monitor to receive sensor data from our Arduino, and played with a couple of Arduino functions.
We will now look at replacing the Serial Monitor with a much more exciting program such as "Processing" which is a free Open Source program that interfaces very easily with the Arduino. It can be downloaded here.
We will use a few processing scripts to bring our Arduino Sensor projects to life !
Stage 6: A simple Processing Sketch: BLINK
Arduino IDE vs Processing IDE
While the processing IDE looks very similar to the Arduino IDE, it is important that you realise that the Processing sketch will run on your computer, and NOT on the Arduino. In fact, you do not even need an Arduino to run a Processing sketch. And that is exactly what we are going to do: Run a Processing sketch without an Arduino.
Parts Required
Once you have downloaded and installed the Processing IDE onto your computer, open the program and copy the following sketch into it, and then press the play button. This is different from the Arduino IDE, in that we do not have to upload it to anything, as it will be running from the computer.
Processing Sketch
|
|
Things to Try
- Change the White background to a black background
- Increase the blink rate to 1 second
Insert on line 9: color Black=color(0,0,0);
Change line 38: background(Black);
Change line 25: delay(1000);
WARNING : Do not increase the speed too much, it may cause an epileptic fit.
Now that wasn't too hard I hope.
And if you want a very good site to learn Processing have a look at these
And if you want a very good site to learn Processing have a look at these
Stage 7: Arduino and Processing Unite.
So how do we get our Arduino to interface with our computer? Well, if the Serial Monitor on the Arduino IDE is not good enough, then you could use any program that is capable of Serial communication. Fortunately, Processing is one of those programs, but you could use C++, Java, Python, Microsoft Excel (using VBA), VB.Net, Gobetwino or some other programming language.
Two programs will be created: One will be uploaded to the Arduino using the Arduino IDE, and the other will run on the computer. In this example we will use Processing as the program that will run on the computer.
Two programs will be created: One will be uploaded to the Arduino using the Arduino IDE, and the other will run on the computer. In this example we will use Processing as the program that will run on the computer.
Enter the following sketch into the Arduino IDE and upload it to the Arduino. It serves to generate a random number between 0 and 400 every 200msec and will send it to the computer via the USB cable , using Serial communication.
Arduino Sketch
1 | /* Stage 7: Simple Arduino Serial Random Number Generator |
Instructions
Once the program has been uploaded to the Arduino, we will want to make sure that it is performing to expectations before moving onto the Processing script.
Open the Arduino Serial Monitor and make sure that you see a bunch of random numbers scrolling down the page. If not, then go back over your code and try again. Once you see the random numbers, then it is safe to move on to the next step.
Processing
The following Processing script will display the Random numbers being sent from the Arduino in the Processing IDE debug window. This particular script is very much like a simplified Arduino Serial Monitor, and it will show you that the Processing Script is successfully communicating with the Arduino.
Processing Sketch
1 | /* Some of the Serial code was adapted from Tom Igoe's example |
When you run the Processing script, a little black window will appear. This is the Processing Graphics window, which is normally where all the action takes place. However in the sketch above, this window does nothing. Instead we make use of the black Debug window which is part of the Processing IDE (below the code window). If everything went to plan, you should see random numbers scrolling down in a similar fashion to the Arduino Serial monitor. Here is an example of what it should look like.
Things to Try
- If you are having problems with COM port selection. Then have a look at the COM port being used on the Arduino IDE to upload sketches to the Arduino. Processing generally uses the same COM port. So make sure to close the Arduino Serial Monitor before running the Processing Sketches.
The image above shows that I am currently using COM PORT 6 on my computer to upload Arduino Sketches. In the Processing sketch on line 32-35, I had this code:
32 | if(comPortList.length>0){ |
We can change line 33 to get Processing to use COM port 6 exclusively. We do this by replacing comPortList[0] with "COM6", as seen below:
32 | if(comPortList.length>0){ |
Stage 8 : Arduino and Processing - Random Font Project
Arduino and Processing are speaking to each other by this stage, and we will keep our original Arduino Sketch to produce random numbers for us. Sure, we don't actually need the Arduino to do this for us, because Processing is more than capable of doing this itself, but we are building up towards an interactive sketch, so lets just go through the motions.
Just in case your mouse scroll wheel doesn't move upwards, here is the Arduino Sketch again:
Arduino Sketch
1 | /* Stage 8: Simple Arduino Serial Random Number Generator |
Upload the Arduino sketch to the Arduino, and then put the following code into the Processing IDE:
Processing Sketch
The output of this sketch should look something like this:
For stages 9 and above: Click Here
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 | /* Simple Serial ECHO script : Written by ScottC 03/07/2012 */ |
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 | /* Simple Serial ECHO script : Written by ScottC 04/07/2012 */ |
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 | /* Simple Serial ECHO script : Written by ScottC 05/07/2012 */ |
Jumper: Arduino controlled animation
In this project, I have connected an Arduino to my computer and used a photoresistor to control an animation on the screen. Other sensors could have been used, but I chose a photoresistor because it feels like magic!!
The photoresistor responds to changes in ambient light as my hand moves up and down. The Arduino sends the reading to a Processing sketch on the computer via a Serial command (through the USB cable). The processing sketch interprets the signal from the Arduino and selects the appropriate picture to display.
I took a series of screenshots from the following YouTube video: http://www.youtube.com/watch?v=h6nE8m74kDg And after borrowing a bit of code from these sites (1,2), the project was born.
This idea is not new, nor my own. There are many people who have done this project before, but I thought to blog about how I have done it, just for fun.
The code above was formatted using this site.
The code above was formatted using this site.
The photoresistor responds to changes in ambient light as my hand moves up and down. The Arduino sends the reading to a Processing sketch on the computer via a Serial command (through the USB cable). The processing sketch interprets the signal from the Arduino and selects the appropriate picture to display.
I took a series of screenshots from the following YouTube video: http://www.youtube.com/watch?v=h6nE8m74kDg And after borrowing a bit of code from these sites (1,2), the project was born.
This idea is not new, nor my own. There are many people who have done this project before, but I thought to blog about how I have done it, just for fun.
The Project Movie
Components Required
- Arduino Uno (and associated software), and USB cable
- Photoresistor or Photocell
- 10K resistor
- Wires to put it all together
- Processing IDE from http://processing.org
- Computer/laptop
The Arduino Sketch
The Arduino Code:
You can download the Arduino IDE from this site.1 | /* Jumper: Using an Arduino to animate: |
The code above was formatted using this site.
The Processing Code:
You can download the Processing IDE from this site.1 | /* Jumper: Using an Arduino to animate |
The code above was formatted using this site.
The pictures
Captured from this YouTube Video: http://www.youtube.com/watch?v=h6nE8m74kDg
Mouse Controlling Arduino LEDs
Use a mouse to control LEDs attached to an Arduino. This project uses the processing language to transmit the mouse coordinates to the Arduino, which then uses this information to turn on some LEDs. Please see the video below to see it in action.
Components Required for this project:
- Arduino UNO
- Breadboard
- 9 LEDs
- 9 x 330 ohm resistors
- Wires to connect the circuit
- USB connection cable: to connect the computer to the Arduino
- A computer: to run the processing sketch, and to compile / upload the Arduino sketch
- Processing Program installed on computer
- Arduino Program installed on the computer
Arduino Sketch
This was made using Fritzing.
Arduino Code
You can download the Arduino IDE from this site.1 | /* This program was created by ScottC on 9/5/2012 to receive serial |
The code above was formatted using this site.
Processing Code
You can download the Processing IDE from this site.1 | //Created by ScottC on 12/05/2012 to send mouse coordinates to Arduino |
The code above was formatted using this site.
Reading from a Text File and Sending to Arduino
The following tutorial will demonstrate how to Read values from a Text file (.txt, .csv) to blink 1 of 9 LEDs attached to an Arduino. It uses the combination of an Arduino and Processing program to process the file. The Processing program will read the text file in real time, only sending new information to the Arduino.
Components Required
- Arduino UNO
- Breadboard
- 9 LEDs
- 9 x 330 ohm resistors
- Wires to connect the circuit
- USB connection cable: to connect the computer to the Arduino
- A computer: to run the processing sketch, and to compile / upload the Arduino sketch
- Processing Program installed on computer
- Arduino Program installed on the computer
- A comma separated text file (*.txt).
Arduino Layout
The Text File
- Open Notepad or equivalent text file editor, and paste the following data into it.
1,2,3,4,5,6,7,8,9,8,7,6,5,4,3,2,1
- Save the file on your hard drive. In my case, I have chosen to save the file at this location.
D:/mySensorData.txt
- It should look like the following screenshot
Additional notes regarding the Text file:
- Just remember what you call it, and where you saved it, because we will be referring to this file later on in the Processing script.
- Keep all values on the same line.
- Separate each number with a comma.
- The number 1 will blink the first LED which is attached to Pin 2 on the Arduino.
- The number 9 will blink the last LED which is attached to Pin 10 on the Arduino.
Processing Code
You can download the Processing IDE from this site.1 |
|
I used this site to highlight and format my code.
Once you have copied the text above into the Processing IDE, you can now start working on the Arduino code as seen below.
Arduino Code
You can download the Arduino IDE from this site.Copy and paste the following code into the Arduino IDE.
1 |
|
Additional Information:
- The Arduino code will still work without the processing program. You can open the serial monitor window to send the commands to the Arduino manually. In fact, if you encounter any problems, I would suggest you do this. It will help to identify the root cause of the problem (ie Processing or Arduino Code, or physical connections).
- If you choose to use the Serial Monitor feature of the Arduino IDE, you cannot use the Processing program at the same time.
Once you have assembled the Arduino with all the wires, LEDs, resistors etc, you should now be ready to put it all together and get this baby cranking!
Connecting it all together
- Connect the USB cable from your computer to the Arduino, and upload the code.
- Keep the USB cable connected between the Arduino and the computer, as this will become the physical connection needed by the Processing Program
- Make sure that you have the text file in the correct location on your hard drive, and that it only contains numbers relevant to the code provided (separated by commas).
- Run the Processing program and watch the LEDs blink in the sequence described by the text file.
- You can add more numbers to the end of the line, however, the processing program will not be aware of them until you save the file. The text file does not have to be closed.
Other programs can be used to create text file, but you will need the processing program to read the file and send the values to the Arduino. The Arduino will receive each value and react appropriately.
SIMILAR PROJECT: Use a mouse to control the LEDs on your Arduino - see this post.
SIMILAR PROJECT: Use a mouse to control the LEDs on your Arduino - see this post.
An alternative Processing Sketch
This Processing sketch uses the loadStrings()method instead of the FileReader method used in the first sketch. This sketch also provides better control over sending the values to the Arduino. When the sketch first loads, the application window will be red. By clicking your mouse inside the window, the background will turn green and the file will be imported and sent to the Arduino, with every value being sent at half second intervals. If you update the text file and save, only new values will be transmitted, however, if you want the entire file to transmit again, you can press the window once (to reset the counter), and then again to read the file and send the values again from the beginning of the file.
I personally like this updated version better than the first, plus I was inspired to update this blog posting due to the fact that some people were having problems with the FileReader method in the first sketch. But both sketches should work (they worked for me).
I personally like this updated version better than the first, plus I was inspired to update this blog posting due to the fact that some people were having problems with the FileReader method in the first sketch. But both sketches should work (they worked for me).
1 |
|
Interfacing yor robot to your PC using Gobetwenio (can work with any MCU)
I am currently working on a project where I need to teach my robot to "see" using an ultrasound sensor. In particular it must find and collect drink cans on a playfield and return them to a specific location.
To make the programming easier I wanted to take the sensor output from the robot and display it on the computer as a chart. As I am a terrible programmer I did a quick google search and came up with Gobetwenio.
read raw gpa data from gps module to arduino
Hey guys I am trying to read raw data from a gps module using TTL communication on RX pin 0 on the arduino mega. i dont know how to program it since i am total noob at arduino programming.
can someone help me out please.
< Later
Posts 41—50 from 50