sensors

Although the Arduino effectively captures incoming sensor data, executing code typically in the microsecond range, challenges arose in transmitting data between the Arduino and Max. The data transfer speed was insufficient. The focus was primarily on creative project realization rather than technical elegance, leading to a preference for simpler solutions, even if they are not the most efficient. In this case, handling all data calculations in Max proved unfeasible. It became necessary to calculate RPMs using the Arduino and transmit a running tally of the current RPMs to Max, along with data from the Force Sensing Resistors. This posed a significant technical challenge, as RPM calculations require triggers from the Hall effect sensors while simultaneously updating data from the Force Sensing Resistors. Typical Arduino sketches utilize a single loop function that continuously executes, which could delay code execution by waiting for incoming data from the Hall effect sensors, consequently interrupting data transmission to Max. A solution was found through hardware interrupts, allowing data from the Hall effect sensor to be read outside the loop function. This approach enabled a constant stream of RPM data to be sent to Max, reducing the risk of inaccuracies due to missed sensor triggers. The workshop will introduce the design of the project's interactive media/music system, exploring interactivity with the Arduino microcontroller platform by integrating sensors with bicycles to control musical output. Hall effect sensors will measure the speed of the rear wheel, while pressure and flex sensors will capture rider movements. The design will address physical computing, translating physical actions into computer data. One of the objectives of Movable Party is to create an interactive experience for participants, with power generated from a hub motor attached to the rear wheel of each bike, directly correlating the speed of the rear wheel to the amount of power generated.

In this electronic schematic design, the project leverages the capabilities of the Arduino microcontroller to facilitate real-time data processing and transmission. The core components include Hall effect sensors, which are strategically placed on the bicycle to detect the wheel's rotational speed. These sensors output a digital signal each time a magnetic field is detected, corresponding to a wheel rotation. The Arduino is programmed to capture these signals and calculate the RPM by measuring the time intervals between triggers.

To ensure that the Arduino can handle multiple tasks simultaneously, such as reading from the Hall effect sensors and the Force Sensing Resistors, hardware interrupts are implemented. This allows the Arduino to respond to sensor signals immediately without being hindered by the main loop execution. The Arduino's interrupt service routine (ISR) is configured to handle the Hall effect sensor inputs, thus enabling precise RPM calculations without data loss.

The Force Sensing Resistors (FSRs) are connected to analog input pins on the Arduino. These sensors measure the pressure applied by the rider, translating physical interactions into variable resistance values that the Arduino reads as analog voltage levels. The data from both the Hall effect sensors and the FSRs are processed and formatted for transmission to Max, ensuring a continuous flow of information.

The communication between the Arduino and Max is typically established through a serial interface, allowing for the sending of formatted data packets. The data structure includes the current RPM and the pressure readings from the FSRs, which are transmitted at regular intervals to maintain an updated state in Max.

Overall, this project exemplifies the intersection of physical computing and interactive media, creating an engaging experience for participants while addressing the technical challenges of real-time data processing and transmission. The design emphasizes the importance of selecting appropriate methods and components to achieve the desired outcomes efficiently and effectively.Though the Arduino has no problem catching the incoming sensor data (it typically executes code in the range of microseconds (1 millionth of a second), I was running into trouble passing the data between the Arduino and Max. Without getting too technical, the data transfer speed was too slow. As someone who tries to be primarily concerned with the realization of creative projects rather than elegant technical solutions, I will admit that I always aim for the simplest solution even if it isn`t the most efficient. Sometimes, as in this case, the simplest solution (handling all of my data calculations in Max) just isn`t going to work.

I realized I was going to have to calculate RPMs using the Arduino and then transmit a running tally of the current RPMs to Max (along with data from the Force Sensing Resistors, as seen in this video ). I knew that this could pose a large technical problem. I would need to calculate the RPMs by taking the triggers from the Hall effect sensors while at the SAME TIME I would need to be constantly updating the data from the Force Sensing Resistors.

Typical Arduino sketches have one function loop(), which runs over and over while the board is on. Pausing to wait for incoming data from the Hall effect sensors would delay the execution of my code and stop the data being sent to Max I needed to do two things at once. Fortunately in the world of open source technology, the solutions to many technical challenges lie online.

This great example by Zitron shows how to use hardware interrupts to read in the data from the hall effect sensor outside of the loop() function. The result is that I can just send a constantly updated stream of RPM data to Max. This turns out to be a much better solution, because if I miss a sensor trigger between the Arduino and MAX, the RPM data will be wrong (sometimes VERY wrong).

If I miss one read of RPM data, it`s not a big problem because I am constantly sending the current number of RPMs. The bigger lesson here is that the easiest solutions are always the best, but sometimes an easy solution just wont work.

In that case you have to delve deeper. While you don`t want technical complexity to derail your project, sometimes more complex solutions end up being the most elegant. In this workshop, we will introduce the design of the project`s interactive media/music system. In particular, we will explore interactivity and the Arduino microcontroller platform by attaching sensors to the bikes and using the resulting data to control musical output.

Specifically, we will be using Hall effect sensors to measure the speed of the rear wheel of the bike, as well as pressure and flex sensors to capture movements of the riders. We will also discuss issues of design and physical computing ”using sensors to translate (transduce) action in the physical world into computer data.

One of the goals of Movable Party is to provide an interactive experience for audiences/participants. Since power will be generated from a hub motor attached to the rear wheel of each bike (see this post ), the speed of the rear wheel directly translates to the amount of power generated.

Detecting how fast the rear wheel is moving thus seems like the most obvious/important piece of data to capture from these stationary, power-generating bikes. The easiest way to detect the speed 🔗 External reference