For this week’s assignment, I use the sound sensor to control the LEDs depends on the different levels of the sound inputted.
List of Materials
1 x Elegoo Uno R3
1 x Full sized breadboard
1 x sound sensor
3 x LEDs
How it works:
three LEDs will blink when the sound’s value changed, but I noticed that the sound sensor is not that sensitive to detect the accurate sound.
code:
video:
This week’s assignment was to creatively rethink how sound and/or light could be incorporated into projects by modifying the input sensors. I decided to work with capacitive sensing because I love the possibilities it provides. It allows us to make our own sensors and enhances the quality of the interactive experience.
List of Materials
1 x Elegoo Uno R3
1 x Full sized breadboard
1 x Piezo buzzer
3 x Graphite strips
3 x LEDs
Resistors: 3x 220 Ohms (for the LED), 3 x 1 Megaohms (for capacitive sensing)
Jumper wires
Fritzing diagram
Description of assembly
How it works
Capacitive sensing works on the principle of using a conductive material to complete the circuit. This circuit works as follows. A high resistance of the order of a megaohm is placed on the breadboard, both ends of which are connected to say, digital pins 2 and 3. Digital pin 3 acts as the input and allows a steady stream of electrons to flow through the circuit. The resistor inhibits the flow and only lets a small number of electrons pass through the other end. The other end in addition to being connected to a digital pin is also attached to a jumper wire. When we touch the metallic end, we pass on a large number of electrons from our body to the circuit. The Arduino can sense this change and can be coded to control an output by defining a threshold value.
Iterations
Graphite conducts electricity and this property can be utilized in interesting ways. I shaded some bits of paper with an HB pencil and connected them to the breadboard so that they could act as switches. For the first iteration I decided to make an instrument where, on pressing each key, one would hear a different, pre-programmed song through the Piezo buzzer. I first tried with the example code melody to see whether all three switches were working individually. On graduating to coding different songs, I had limited success.
This further led me to think about how a user could make their own music. On pressing a key, they would hear a tone, akin to a piano. The various sequences and combinations could culminate in unique tunes. I had trouble associating one LED to one graphite switch. After multiple iterations, it turned out to be a glitch in the code which I then rectified.
Code
I’m making a sound visualization project using Arduino as an input and Processing as an output.
Arduino: I’m using a photocell sensor to detect the light from the environment and map the data to use in Processing to control the alpha value of the floating points.
Processing: I’m using minim library to visualize the audio file and created 300 points floating with it.
1* photocell sensor
1 * 10k resistor
Wires & jumpwires
Arduino board
Arduino: StandardFirmata
Processing:
import cc.arduino.*;
import org.firmata.*;
import processing.serial.*;
import ddf.minim.*;
import ddf.minim.analysis.*;
import cc.arduino.*;
Minim minim;
AudioPlayer song;
FFT fft;
Arduino arduino;
int num = 300;
PVector[] posArray = new PVector[num];
float pTime = 0;
float vel;
PVector[] noiseArray = new PVector[num];
int sensorPin = 0;
int sensorVal = 0;
float newSensorVal;
void setup() {
size(1000, 800, P3D);
minim = new Minim(this);
println(Serial.list());
arduino = new Arduino(this, Arduino.list()[1], 57600);
song = minim.loadFile(“1.mp3”, 512);
song.loop();
fft = new FFT(song.bufferSize(), song.sampleRate());
for (int i = 0; i < num; i++) {
float r = random(300,400);
float theta = random(TWO_PI);
float y = r*sin(theta);
float x = r*cos(theta);
noiseArray[i] = new PVector(x, y);
posArray[i] = new PVector(0, 0);
}
arduino.pinMode(sensorPin, Arduino.INPUT);
}
void draw() {
background(0);
pushMatrix();
translate(width/2, height/2);
scale(1.5);
fft.forward(song.mix);
noStroke();
println(arduino.analogRead(sensorPin));
sensorVal = arduino.analogRead(sensorPin);
newSensorVal = map(sensorVal,800,960,50,250);
//float a= random(100,200);
fill(random(0,255),random(0,255),random(0,255),newSensorVal);
for (int i = 0; i < num; i++) {
ellipse(posArray[i].x, posArray[i].y, 2, 2);
}
popMatrix();
update();
}
void update() {
float time = millis()*0.001;
float dt = time – pTime;
println(dt);
pTime = time;
float level = song.mix.level();
float fftVal = fft.getBand(300);
vel = map(fftVal, 0, 0.1, 0.05, 0.5);
for (int i = 0; i < num; i++) {
noiseArray[i].x += vel * dt;
noiseArray[i].y += vel *dt;
float xScale = map(noise(noiseArray[i].x), 0, 1, -1, 1);
float yScale = map(noise(noiseArray[i].y), 0, 1, -1, 1);
posArray[i].x = xScale * 300;
posArray[i].y = yScale * 300;
}
}
For a very long time, I have been fascinated by e-textiles because they lie at the intersection of craft and electronics. I did not know where to begin my exploration from and decided to follow along a simple Sparkfun tutorial to make a light-up plush (https://learn.sparkfun.com/tutorials/light-up-plush)
Materials required
Lilypad ProtoSnap
3V Coin Cell Battery
Conductive thread
Needle
Plush pattern
Felt piece: 10 by 10 inches
Scissors
Fabric glue (optional)
Beads, pompoms, ribbons, buttons, glitter to decorate
Diagram (taken from the Sparkfun website)
Description of assembly
How it works
I was surprised to find that working with e-textiles isn’t very different from working with the Arduino hardware. It is based on the same principles of electronics that we are familiar with. A 3V coin cell powers the circuit, and the electrons, regulated through the side switch and the button, light up the LEDs.
Challenges
I had difficulty debugging my circuit. Unlike a “traditional” circuit, it was time-consuming to check the connections- as I had to re-embroider entire sections. Later I realized, that my circuit was getting shorted because of the long, untrimmed pieces of wire. After securing a few connections, and trimming the ends, it started working!
Future Iterations
I am excited about incorporating physical elements or characters in the process of digital storytelling. I feel they make the story more compelling. I was imagining a choose-your-own-adventure story, that plays out on the screen, depending on one’s choices in the real world. So these characters could act as controllers that are affecting the narrative. Continue reading
PART 1
Goal of the Project:
The intention with this project was to explore the infinite creative possibilities of playing with the relations between light and sound using a microcontroller. In this particular case, I wanted to explore new sensors such as BIG sound as input that triggers other process such as turning on and LED.
List of Components:
Assembly Process:
To create this project, first, the big sound module has to be connected to Arduino (We can use a Digital pin or Analog Pin. In this case, we used the digital pin 3, but we need to tell Arduino we are using it as DIGITAL input). Then we connect the LED to a digital pin 4 as an OUTPUT.
How it works:
To test the Big sound module, the 2 LEDs of the module will light up. In order to control the sensibility of the module, we need to move the built-in potentiometer in the module using a screwdriver. The idea is to turn it to the left to reduce resistance and add sensibility. As soon as the led turn off, that means the module is ready. Then we connect an LED to a pin and set it as OUTPUT. The result? The LED will respond to the high and low frequencies received from the sounds from the surroundings.
Problems:
Controlling the sensibility of the bid sound module represented a challenge. I wasn’t able to get an important sensibility value in order to control the LED. To test it, I had to create sounds with deep basses and had to be fairly loud. I also test the “small sound” module and the issue was even worst.
Arduino Code (File):
https://www.dropbox.com/s/rgi5s89rif0mg1b/DarioNarvaez_HW6.ino?dl=0
Circuit Diagrams:
References:
https://create.arduino.cc/projecthub/iotboys/control-led-by-clap-using-arduino-and-sound-sensor-e31809
PART 2
I2C Protocol:
Or Inter-Integrated Circuit is a protocol that allows to connect multiple “slave” devices to a one “master” device. It’s the most used between electronic devices (microcontrollers, sensors…cellphones, cars…). The connection between a microcontroller (Arduino) with sensors and modules are good exaples of Master-Slave relation, where both can communicate to each other, but the communication is initiated only by the master.
Pros:
Only requires 2 wires that can support multiple devices for the communication (bus connection) up to 127 devices.
Simple to use, reliable and inexpensive.
Cons:
Short distance communication with a single device
Hardware is more complex than other protocols
Resource:
and it stands for universal asynchronous receiver/transmitter, it is one of the fundamental/basic ways of communicating the serial to another information source wirelessly. Continue reading
Part 1
Part 2
SPI-
It is a synchronous data transfer technique which means there is a dedicated clock signal generated by the bus controller. It supports multi-master bus support and bidirectional transfer. It is a serial data protocol used by microcontrollers for communicating one or more peripheral devices quickly.
There is usually always one main master device controlling many other peripheral devices.
