Saving Arduino data as CSV in Processing

Alright, so we’re diving into how to set up your Arduino and Processing to save a CSV file.
First off, use the Arduino sketch file from our last session, making sure your Arduino is connected and programmed to receive data.
Now, the aim here is to process that incoming data and whip up a program that will save it as a CSV file.
Don’t forget, you’ll need to save your Processing file beforehand; something like ‘simple pm2 2008 logo’ will work just fine.
If you’re using Windows, you can usually find the Processing application nestled in your Documents folder, and the same goes for Mac users.
So, just double-check you’re in the right folder on your OS to keep things running smoothly as you set this all up..

So, you’ve got this cool PM2 2008 logo made in Processing, but it seems like the text size could use a little boost.
To actually save some data into a CSV file, you’re going to use the PrintWriter class.
First up, set your output window to 200 by 500 pixels and give your file a snazzy name.
The frame rate, set at 10, decides how many times the draw function runs each second, which is super helpful for saving mouse coordinates when you click and drag around.
Oh, and don’t forget about the keyPressed function—this little guy kicks into action whenever you hit a key.
It’ll ultimately help you stop and exit the program once you’ve wrapped up your data transmission!.

So, here’s the deal: whenever you hit a specific key, that’s your cue to wrap things up; it saves everything in its current state.
As you click or drag around with your mouse, you’ll see points pop up, and when you press ‘Enter’, it exits the program and spits out a CSV file with all those coordinates.
Even though it looks like an Excel file, it’s technically a text file that you can open in Excel by just separating the values with commas.
Now, if you want your devices to chat with each other, you’ll need to connect to the serial port.
This means adding a serial-related library packed with all the functions you’ll need.
With the internal Serial library, your program can handle serial communication like a pro, but first, you’ve got to declare a variable for the serial port.
Plus, using the printArray function, you can check out what data’s being sent over through the console.
You’ll also see available communication ports, like the COM ports on Windows.
For example, your Arduino will show up as a DTY USB modem, and you can easily copy that for your records..

Getting started with serial communication is pretty straightforward! First up, connect the serial port and pop in the code to create a TS instance.
Next, you’ll want to input the port name and set the board rate to 9600, along with configuring those essential buffer settings.
When your Arduino sends a carriage return/new line code, it acts like a line break, which helps us store and send data effectively.
Even though we’re not using the drone right now, we’ll set up serial events to gather buffer data based on that line break.
And just to keep things tidy, we use trim to get rid of any white space or extra characters from each line before sticking it in the message variable..

So, here’s the scoop on setting up serial communication.
First off, all the data gets neatly packed into a buffer, so it’s ready to go while keeping things tidy for the drone.
Then, there’s the port’s readString function, which is like a detective for your data, pulling in lines from the Arduino whenever it sees a line break and saving them in a message variable.
To keep things looking sharp, we use trim to zap any extra whitespace, making sure our message stays valid and isn’t null .
Finally, you’ll see that the message gets printed to the console and saved to a file, and if you hit a specific key, it sends all that data and wraps things up nicely..

So, let’s talk about how to get the serial library up and running! First off, we’ve got the serial library all set up, and we’re declaring the PrintWriter class to handle some file writing along with a serial variable instance.
To connect, we’ll create this instance using the Arduino port name, and don’t forget, the PrintArray is handy for scanning.
We’re also tuning the board rate to a smooth 9600 and setting up a port buffer that includes that all-important carriage return symbol.
Plus, we’ll cut out any unnecessary size and frame rate settings, and when it comes to outputting CSV data, we’ll tweak things to avoid any overlap—like adding a nice header to keep everything organized..

So, let’s dive into organizing GSP files! First off, all the info from our last meeting has been carefully put together, making sure the first row of the GSP file is set as the header.
This little detail is crucial for keeping everything neat and tidy.
Next, you’ll want to swap out those slashes for commas as item separators; for example, change ‘item, item two, item three’ into ‘item 1, item two, item three’ to keep things clear.
To make life easier when entering the header, we use the serialEvent function, which takes care of organizing commands and managing incoming data during serial communication.
Data is read by using port.readString(), and if there are any empty values, we just trim them down and check to ensure we have valid messages before saving to the file..

So, here’s the deal: once I hit that key, I make sure to wait until all the data is fully entered before I wrap things up.
The program runs and every 5 seconds, it’s busy printing stuff to the console while also saving all that data into a CSV file.
But here’s the catch—when I hit the key to finish up, the program shuts down, and I’m left with these weird garbage values , which definitely shouldn’t happen if everything’s working smoothly.
Now, I gotta admit, this setup isn’t the best; it has two pretty big flaws: for one, checking if the data is valid can be a real pain, and on top of that, the data length is a bit overkill since we’re sending numbers as ASCII code using three bytes instead of just one.
But don’t worry, to fix these issues, I’ve got a plan to dive into packet forms in the next session to make sure we’re sending and receiving data accurately, while also parsing and checking those pesky checksums..