Wednesday, November 30, 2016

Mini-Project 2: Final

My mini-project worked, although it wasn't much to look at. I hoped for the spinning dangling parts to be more elaborate, and to make noise as it moved; I wanted it to be something that people wanted to make move.

I also didn't realize how violently the servo would spin them with my initial settings, so I had to stop it after the threads would get wrapped around the servo. And I should've made a stand for it or something, as hanging it wasn't an option, and holding it made the motion detection useless (since the camera itself was always moving).

I want to use a similar principle for my final, although not the servo; it was way too loud.

Demonstration

Mini-Project 2: Servo

I had some last-minute trouble with the servo; namely, it was pretty unpredictable in terms of whether it would stop and start with the camera's motion detection.

Demonstration

The blue LED is my indicator, and turns on while the camera is detecting motion, then turns back off. That it responds correctly shows that it's not the camera's fault; the servo itself is the issue.

The only solution I found (which only really fixed the outcome, it didn't really correct the problem) was to upload another sketch in which the servo was set to its stopped position. However, even then it sometimes ignored the sketch and continued to spin. I would have to continue to unplug and plug in the Arduino and upload the sketch until the servo decided to listen.

Mini-Project 2: Camera

Demonstration

I ultimately got the camera to work, but as can be seen in the video, it's still occasionally unreliable. I can't really predict when it's going to work and when it's not, but it seems to work the majority of the time.

I also feel that I should've shortened the delay on the camera's code, so that only a few milliseconds after the movement stops, the servo stops.

Mini-Project 2: Getting Stuff to Work

For the servo, I started out with a potentiometer, just to make sure the servo was actually changing speed. Demonstration.

For the camera, I had trouble getting it to continuously detect motion. The source code has it stop so that it can write the picture it takes, but I needed it to continue detecting motion as long as something was moving in front of it.

The main issue was that I was phrasing it as two separate if-statements, so that it would constantly switch between motion and no motion for each new input. Using an if, else if statement worked:

 if (cam.motionDetected()) {
   Serial.println("Motion!");
   cam.setMotionDetect(false);
   digitalWrite(ledPin, HIGH);
   s.write(103);
   delay(200);
   cam.resumeVideo();
   cam.setMotionDetect(true);
 } else if (! cam.motionDetected()) {
   Serial.println("Still.");
   digitalWrite(ledPin, LOW);
   s.write(92);
   delay(200);  
 } else {
  s.write(92);
 }

However, I also had to -- once the camera detected movement -- tell it to stop detecting movement. These three lines
   cam.setMotionDetect(false);
   cam.resumeVideo();
   cam.setMotionDetect(true);
disable and enable the motion detection. Without it, the camera continued to switch back and forth between detecting motion and no motion even with constant motion in front of the camera. I suppose it stops the else if part from being executed.

The s.write(); refers to the servo speed.

Mini-Project 2: Parts

Two of the main components I used were the TTL JPEG Camera and the SM-S3317SR Servo.

The camera requires its own library, and has a couple demos along with it. The one I worked on editing for my own purposes was the motion detection example. The screenshot is from my serial monitor; the camera takes a picture each time it detects movement. It saved it twice as IMG000 because I didn't have an SD card for it to save it to.

The two things I needed to change were it taking a picture, and it stopping motion detection briefly once it detected motion.

The other component was the 360 servo. Rather than being able to tell it to go to a particular angle, you tell it what speed you'd like it to rotate, and which direction. The center for this servo is 92; anything below 92 will make it rotate counterclockwise, and anything above, clockwise. The further the number is from 92, the faster it will spin.

Final Project Process 2/5


Yesterday I went with Dominique to the FabLab to cut pieces to make pots for my plants. I cut them out of clear plexi to coat in spray paint to give them a frosted finish. The frost is to diffuse the light of LEDs to make the plant "glow" when you come near. I really need to make sure the inner layer of the pot is watertight to prevent any seepage onto the arduino or breadboard.

Final Project Process 1/5




Initial concept art for final project. Two similar plants in identical pots. One of the pots features a rangefinder that triggers LEDs to glow when a participant comes near. It also features a "theremin" of sorts to where it "boops" when touched.

Conceptually, the idea is that one plant responds to interaction as a means of showing "appreciation" that you give it attention. Given that it reacts to interaction, the participant is more inclined to touch. Will the plant benefit from the extra attention? Will the constant stimulation suffocate the plant and kill it? Why do we need to be rewarded to care about something?

Art.

Mini Project Process 5/5

Post-Critique Thoughts:

Lessons Learned:
1. Plywood is much lighter than basswood.
2. Basswood is much more expensive than plywood.
3. The two look about the same.
4. Consider friction.
5. DC motors suck the life out of 9v batteries.

Since the wheels would not turn at all while touching anything, I tried to maximize the power. By simultaneously subtracting the friction, the wheels spun with too much gusto, and the piece fell apart. The piece was conceptually sound, technically simple, physically fragile, and a monstrous headache to construct. Albeit a total disaster, it was functional for all of three seconds.

May it rest in peace.

11/30 Final Project - Process 1








My circuit for the final project is very simple: one or two piezos directly connected to the Arduino Leonardo board. They will be attached to the sides of a glass container where they will measure the vibrations from people moving their fingers and hands in the water. The code I will use will be a combination of the codes from my two mini projects: different ranges of vibrations will trigger different mapped keys that control a character in Unity. If I have two piezos, each piezo can control a certain aspect of movement.

Final Project | Process 2


Monday, November 28, 2016

Final Project | Process



In-class exercise 11/21


-This was made with the Autodesk online program.

mini_project2[5]


-I was able to make Super Mario Clouds.
-I wanted the case to look like a gaming console, something like the PS4, but this is how it ended up looking. I think it looks like an old big camera, that you had to get inside some curtains in order to take the picture.

mini_project2[4]


-I was able to make Totally F*cked. The image blinks because it constantly re-rendering everything.

mini_projec2[3]


-I was able to get the clouds to move.

Monday, November 21, 2016

Sunday, November 20, 2016

Mini Project Process 4/5

Hollow husk of what my project is intended to be.
As the participant nears the piece, the two circle panels spin wildly. Pennies are provided for the participant to drop into the hole cut into the top of the plexiglass. Because the panels spin so quickly, it's near impossible for the penny to drop into the gilded slot.

Concept: From afar, the task appears simple: a straight shot drop from the top to the bottom. Then you add the factor of the pegs. Then you add the factor of the pegs spinning. Then you add the factor of the pegs spinning terrifyingly fast.

Although you can see the gilded destination at your fingertips, the journey is an entirely different endeavor. Plinko is a classic children's game, and inherently simple and easy. Real life isn't A to B.
A ricochets between C, D, E, F, G, gets fucked over by H, only to never reach B. As A, you are expected to reach B. Reaching B is simple. A child could reach B. If everyone else could reach B, why not you? Reaching B is the standard. What is your excuse for not reaching B? B is right there. You are not trying hard enough to reach B. Try harder to reach B.

Mini Project 2 | Process 5



My project is now completed! My concept has changed drastically from when I began this project. Rather than reading body temperature or simply alerting to cold or warm temperatures, this finicky device reads that it is "too cold" to go outside if it is below 75 degrees and "too hot" if it is above 80 degrees. Not only is this an accurate representation of how I personally feel about the weather, but I've recently been battling with stress and what may or may not be depression (I haven't had time to see a counselor, so you know). Sometimes, it is easy to convince myself that one small inconvenience is enough to offset the entire day. If the temperature is even slightly off, why bother going outside? Why bother doing anything? But very rarely, I feel like things are okay and I actually want to get up and do things during that nice 76-79 degree window. I don't think this is actually the best description of my concept, but I'm hoping it at least gets a vague point across. My piece speaks better for it than I do.

Mini Project Process 3/5

Here is a video with me successfully getting the ultrasonic rangefinder to function. From here, I detached the piezo and instead switched it out with a DC motor. At this point, I was at a standstill.

I needed the ultrasonic rangefinder to trigger a DC motor, which needs 9v of power to spin. However, the arduino crashes when you feed more than 5v of power to it. The DC motor that requires 5v of power is too weak to move my parts. I was in the studio most of yesterday moving wires around to get something to work.

Also I nabbed the last 9v battery and it just died on me.

I'm trying.

Mini Project 2 | Process 4


I've opted to create a device that reads the temperature of the room it's in. It will read as "too cold" if the temperature is below 75 degrees and "too hot" if it is above 80 degrees. This is an intentionally small window of "good temperature". I'll explain my concept in my final post. As of now, all of the pieces are functional, it operates as intended, and I am finishing up the container for the device. 

Mini Project 2 | Process 3


Oh, boy. I encountered several issues working on this. Not only did my temperature gauge break after I soldered it to extend it out from the wrist wear I intended to make, but the breadboard was also not cooperating despite being connected to the Arduino. I had difficulties with both of the temperature gauges heating up as well. I don't think I'll make this a wearable piece. I have another idea in mind.

Mini Project 2 | Process 2

My idea shifted to a portable temperature gauge that you could wear around your wrist that would alert you if your body temperature rose too high or dropped too low. This was meant to be a sort of addition to my previous project where your body responses were transferred into data that could be referenced at any point, and would alert you and others as to your current physical state of well being.
Unfortunately,
I underestimated how little I knew about the Lilypad Arduino. I transferred this concept to a breadboard rather than trying to fiddle with this device any longer.

Tuesday, November 15, 2016

Mini Project 2 - Process 3

I constructed the bin to hold the water and sand out of binder's board and acrylic. The water and sand sits in a plastic bag sits inside, while the LED's light from beneath through the acrylic. The lights get brighter and flash faster as vibrations increase. You can even make patterns in the sand.

The box gets heavy when full of water, but seems pretty sturdy. Unfortunately when I tested it out, it leaked a little bit. I will just reinforce the edges of the bag and make sure there are no tiny holes; I hope that fixes whatever happened. I wanted to power the Arduino with a battery so it could be away from the computer, but the battery I picked up was dead, I suppose. Being attached to the computer isn't a big deal.



Mini Project 2 Update 4/5

Unlike for my first mini project, I soldered everything and actually managed to not mess up.





I soldered two breadboards together because the length of my box is 6 inches, and the longer breadboard's width would not fit into my box. This worked to my advantage and made things easier for me in the end and now I learned how to connect multiple breadboards together.

The next step from here is to finalize the text I want it to say. I also need to figure out how I am going to hide all the wires once you open the box the arduino will be enclosed in.

Mini-Project 2 Progress #2


This is the first test I did with the water vibrations. If you can see, the numbers are very small, but there does seem to be a reaction from me moving my finger in the water. Since then, I have removed the LED's from the shift register and hooked them up individually to different pins.

I also altered the code to measure the volts from the piezo disk at a more constant rate, and with higher numbers so it can affect the brightness of the LED's. Now all that remains is constructing the basin for the water and sand, and attaching the apparatus.

Mini Project 2 Process 4/5





#include <ArduinoPins.h>
#include <FatReader.h>
#include <FatStructs.h>
#include <mcpDac.h>
#include <SdInfo.h>
#include <SdReader.h>
#include <WaveHC.h>
#include <Wavemainpage.h>
#include <WavePinDefs.h>
#include <WaveUtil.h>

#include <WaveHC.h>
#include <WaveUtil.h>

SdReader card;    // This object holds the information for the card
FatVolume vol;    // This holds the information for the partition on the card
FatReader root;   // This holds the information for the volumes root directory
FatReader file;   // This object represent the WAV file
WaveHC wave;      // This is the only wave (audio) object, since we will only play one at a time


#define playcomplete(x) ROM_playcomplete(PSTR(x))         // save RAM by using program memory strings

#define servo 7
#define redled 9
#define eyeleds 18
#define mouthleds 17
#define midmouthleds 16
#define outermouthleds 19

void setup() {
  Serial.begin(9600);           // set up Serial library at 9600 bps
  Serial.println(F("Wave test!"));

  pinMode(2, OUTPUT);
  pinMode(3, OUTPUT);
  pinMode(4, OUTPUT);
  pinMode(5, OUTPUT);
  pinMode(redled, OUTPUT);
  pinMode(servo, OUTPUT);
  pinMode(eyeleds, OUTPUT);
  pinMode(outermouthleds, OUTPUT);
  pinMode(midmouthleds, OUTPUT);
  pinMode(mouthleds, OUTPUT);

  randomSeed(analogRead(0));


  if (!card.init()) {
    Serial.println(F("Card init. failed!")); return;
  }
  // enable optimize read - some cards may timeout. Disable if you're having problems
  card.partialBlockRead(true);

  // Now we will look for a FAT partition!
  uint8_t part;
  for (part = 0; part < 5; part++) {   // we have up to 5 slots to look in
    if (vol.init(card, part))
      break;                           // we found one, lets bail
  }
  if (part == 5) {                     // if we ended up not finding one  :(
    Serial.println(F("No valid FAT partition!"));  // Something went wrong, lets print out why
  }

  // Lets tell the user about what we found
  putstring("Using partition ");
  Serial.print(part, DEC);
  Serial.print(F(", type is FAT"));
  Serial.println(vol.fatType(), DEC);     // FAT16 or FAT32?

  // Try to open the root directory
  if (!root.openRoot(vol)) {
    Serial.println(F("Can't open root dir!"));      // Something went wrong,
  }

  // Whew! We got past the tough parts.
  Serial.println(F("Files found (* = fragmented):"));

  // Print out all of the files in all the directories.
  root.ls(LS_R | LS_FLAG_FRAGMENTED);
}


void pulseServo(uint8_t servopin, uint16_t p) {

 digitalWrite(servopin, HIGH);
 delayMicroseconds(600);
 while (p--) {
   delayMicroseconds(4);
 }
 digitalWrite(servopin, LOW);
  delay(18);
}

uint8_t pumpkinstate = 0;

void loop() {
   int distsensor, i;
   long time;
   /*
   for (i=0; i<50; i++) {
     pulseServo(servo,0);
   }
   for (i=0; i<50; i++) {
     pulseServo(servo,400);
   }
   return;
   */
   distsensor = 0;
   for (i=0; i<8; i++) {
     distsensor += analogRead(0);
     delay(0.01);
   }
   distsensor /= 8;

   Serial.print(F("Sensor = ")); Serial.println(distsensor);
 
   if (distsensor <= 500) {
     digitalWrite(eyeleds, HIGH);
   }
   if (distsensor > 500) {
     digitalWrite(eyeleds, LOW);
     pumpkinstate = 1;
     // nobody there. one out of 200 times play one of the scary sounds (once every few minutes)
     i = random(20);
     //Serial.println(i);
     if (i == 0) {
       i = random(3);
       if (i == 0) {
           playcomplete("meh1.wav");
       } else if (i == 1) {
           playcomplete("die1.wav");
       } else {
           playcomplete("adult1.wav");
       }
     }
   } else if ((distsensor > 300) && (distsensor < 400)) {
     if (pumpkinstate <= 1) {    // play "hello children"
        playcomplete("meh1.wav");
     } else {
       i = random(60);            // more often
       //Serial.println(i);
       if (i == 0) {
         i = random(3);
         if (i == 0) {
           playcomplete("meh1.wav");
         } else if (i == 1) {
           playcomplete("himself1.wav");
         } else {
           playcomplete("last1.wav");
         }
       }
     }
     pumpkinstate = 2;
   } else if ((distsensor > 100) && (distsensor < 200)) {
     if (pumpkinstate <= 2) {    // play "hello children"
       playcomplete("die1.wav");
     } else {
       i = random(50);            // more often
       //Serial.println(i);
       if (i == 0) {
         i = random(3);
         if (i == 0) {
           playcomplete("adult1.wav");
         } else if (i == 1) {
           playcomplete("hearty1.wav");
         } else {
           playcomplete("stare1.wav");
         }
       }
     }
     pumpkinstate = 3;
   } else if (distsensor < 50) {
     if (pumpkinstate <= 30) {    // play "hello children"
        playcomplete("stare1.wav");  
     } else {
       i = random(3);            // more often
     //Serial.println(i);
     if (i == 0) {
       i = random(2);
       if (i == 0) {
           playcomplete("meh1.wav");
       } else if (i == 1) {
           playcomplete("adult1.wav");
       }
     }
     
   }
    pumpkinstate = 4;
 }
}



void ROM_playcomplete(const char *romname) {
  char name[13], i;
  uint8_t volume;
  int v2;

  for (i=0; i<13; i++) {
    name[i] = pgm_read_byte(&romname[i]);
  }
  name[12] = 0;
  Serial.println(name);
  playfile(name);
  while (wave.isplaying) {
   volume = 0;
   for (i=0; i<8; i++) {
     v2 = analogRead(1) - 512;
     if (v2 < 0)
        v2 *= -1;
     if (v2 > volume)
       volume = v2;
     delay(5);
   }
   if (volume > 200) {
     digitalWrite(outermouthleds, HIGH);
   } else {
     digitalWrite(outermouthleds, LOW);
   }
   if (volume > 150) {
     digitalWrite(midmouthleds, HIGH);
   } else {
     digitalWrite(midmouthleds, LOW);
   }
   if (volume > 100) {
     digitalWrite(mouthleds, HIGH);
   } else {
     digitalWrite(mouthleds, LOW);
   }
   //Serial.print(F("vol = ")); Serial.println(volume, DEC);
  }
  file.close();
}

void playfile(char *name) {

   if (!file.open(root, name)) {
      Serial.println(F(" Couldn't open file")); return;
   }
   if (!wave.create(file)) {
     Serial.println(F(" Not a valid WAV")); return;
   }
   // ok time to play!
   wave.play();
}


Everything works so far. crossing my fingers..

Monday, November 14, 2016

mini project update 2

I changed the code I'm using by making some modifications from a code someone on the internet made to control the digital volume of the wave shield. Their code was a modification of the SoftVolumeHC from the WaveHC library I mentioned in the previous update.

I got the volume to decrease over the duration of the clip playback. It's kinda funky because it pops each time the level drops, as its a digital decrease. The time it takes to decrease volume is dependent on the strength with which one blows on the sensor.


This Arduino command reference sheet has been useful for making the code.

Mini Project 2 Update 3/5

     Unlike for my first mini project, I am going to solder all my wires to my breadboard to make sure nothing pops out when people pick up the box that I am going to use for the case.


I am also planning on using a box I made this summer in sculpture class in order to hide the wires. The box is all black and has a decorative handle. My goal is to make a cut out for the LCD screen so when you open the box all you see is the LCD screen. 


Mini Project 2 Update 2/5

     After trying to get the larger LCD screen to work (and contacting the website's support system) I still could not get the screen to light up and work. Because of time, I am going to use the smaller LCD screen again.

I am still using Project 23 from the Beginning Arduino book as a reference for my code. There are examples on how to move the code so while looking at that structure, I started writing my own to test it out (and it works):

 #include <LiquidCrystal.h> //library
  LiquidCrystal lcd(12, 11, 5, 4, 3, 2); //pin assignment

void setup() {
 lcd.begin(16,2);

}

void loop() {
  //options
  intro();
  second();
 
}

void intro(){
  lcd.clear();
  lcd.setCursor(14,0);
  lcd.print("Once upon");
  lcd.setCursor(16,1);
  lcd.print("a time...");
  delay(100);
    for(int x=0; x<16; x++){
      lcd.scrollDisplayLeft();
      delay(450);
      }
}
     
 void second(){
  lcd.clear();
  lcd.setCursor(14,0);
  lcd.print("there was a");
  lcd.setCursor(16,1);
  lcd.print("girl...");
  delay(100);
    for(int x=0; x<16; x++){
      lcd.scrollDisplayLeft();
      delay(450);
      }
  }

I am still trying to decide what text I want to display. I will be looking at poems and well known stories as a reference, but I might end up writing my own story for this mini project. I am still experimenting with having the text move from left to right- right to left. I am also still playing with the timer within the code to make sure the sentences are legible.

_______________________________
resources I have used so far:

https://code.google.com/archive/p/glcd-arduino/downloads

https://www.sparkfun.com/datasheets/LCD/GDM12864H.pdf ***

http://users.ece.utexas.edu/~valvano/Datasheets/ADM12864H.pdf

http://www.arduinoecia.com.br/2015/12/relogio-arduino-display-128x64-rtc-ds3231.html ***

http://nicuflorica.blogspot.ro/2013/01/arduino-si-un-afisaj-lcd-clasic-16.html

Mini Project Update 2/5 | Xiaoxi Zheng

Mini Project Update 2/5 | Xiaoxi Zheng

I've gotten the Kinect to display the image as desired and I got the sonar proximity sensor to do the initial LED triggering. 


Sunday, November 13, 2016

mini_project2[2]


-I was able to convert any picture into a bitmap and display it on the UTFT LCD screen with the built-in function drawBitmap(xpos, ypos, width, height, scale)
-To get the bitmap, I had to use a program that was inside the Tools folder inside the UTFT library and I had to scale the picture down to 106x80.
-I had to set the scale variable (optional) to 3 in order to make the picture cover the whole screen, which is 320x240. So (106*3)x(80*3)

Saturday, November 12, 2016

Mini Project 2 Process 3/5

Let's see if this 5th attempt is the one that works.


Still need to find a speaker for the project.

I have decided to have the mirror say bizarre things because I think it is excepted to have  a magic mirror say nice things or rude things.

Since I really can't come up with any good ones. I took inspiration from fortune cookies.

the-40-best-fortune-cookie-sayings-that-will-leave-you-bemused-befuddled-or-beguiled



Mini Project 2 Process 2/5

Since the main component of this project is about movement why not let the movement involve the viewer. I'm keep thinking about a magic mirror for some odd reason.  Have the mirror tell you you're fabulous or have it say bizarre things...
stole my brother's mirror for the project..

soldered the sonar sensor


Mini Project 2 Process 1/5

Movement....

I know I want to use an infrared or sonar sensor for this project because I will use one or the other for the final project. Possible thinking about using the wave shield since I spent so much time building one that works...

Mini project update 1

My mini project of using a wind sensor to play audio files has started moving after days of confusion. I was just looking in the wrong places for information. The codes I started with from ladyada's waveshield pages weren't working ( https://learn.adafruit.com/adafruit-wave-shield-audio-shield-for-arduino/play6-hc and https://cdn-learn.adafruit.com/assets/assets/000/010/334/original/daphc.pde.txt).

Well, the second one worked at least, but it took a long time to cycle back to the audio file on my SD card.

Oh, and a note on the SD card: Your wave file has to be formated to 22khz, 16bit, and mono. I did this by uploading the track to itunes after making these the itunes upload settings in preferences. Your file name should also be in ALL CAPS, like ALERT.WAV (and .wav is just the extension, not part of the file name. Right click --> get info to see if this is what your audio file is like.

I downloaded the WaveHC library and dragged the folder from within its zipfile into the Libraries folder within the Arduino system folder. I eventually realized that this gave me some new premade sketches in arduino's sketch library. The one I am using now is called 'daphc'.

I hooked up a wind sensor to A0, as well as 5v and gnd. I inserted some bits of code within the daphc file to make it play my audio file in response to sensorValue. You can see these additions by the //sensor notes.



Next goals:
1. Stop file play back when sensor value falls.
2. Write and record spoken word file.
3. Create enclosure


Wednesday, November 9, 2016

mini_project2[1]


-I found an up-to-date version of the library package with more examples.
-I also found out that this UTFT LCD screen's resolution is 320x280
-It is compatible with Arduino Mega 2560 thanks to the Mega Shield.

Mini Project 2 Update 1/5

     My mini project is a continuation of my original idea for my final project. I am still interested in experimenting with telling a story using the LCD screens for this project. Since the mini project is focussing on the idea of movement, I want to focus on figuring out how to get the text to move around the LCD screen instead of just appearing. Instead of using a motor or servo to show physical movement, I wanted to show movement visually. I want to remove the tilt sensor that I had in my first mini project (that was in charge of generating the text when you move it) and have the text be generated by a timer in the code.

I'm planning on using this larger LCD screen because it will allow me an extra row for text.




I am still trying to figure out how I want to encase this mini project. I might just make a simple box and have the LCD screen just displayed. My original idea was to use a book again, however the process to carve out the inside of the book was lengthly and I was not happy with the outcome.


Monday, November 7, 2016

Mini Project Process 2/5

what i did in class today.

Using a digital caliper, I measured out all the dimensions of my piece. This took the entire class.

Laser cuts.

Mini Project 2 | Process


My second mini project will involve using the Lilypad Arduino kit to sew a proximity sensor into the back of a shirt as well as three servos with fabric attached around the neck area so that if someone comes within a certain spacial area, the neck goes up, similar to how certain lizards respond to threats.


I like the idea of utilizing portable technology in order to enhance the human body in small, every day ways. This particular project emphasizes the idea of "personal space", and alerts the wearer to anyone potentially "threatening" that space by adding a type of "third eye" to their back.

Week 11 | In Class

LCD [Failed]


Week 10 | In Class

Wave Shield


Week 11 Wednesday November 2, 2016 | Projects 23 & 24 in Ch. 8

Project 23 - Basic LCD Control

Project 11 in Project Book -  Crystal Ball



Project 24 - LCD Temperature Display






Week 10 Wednesday October 26, 2016 | Wave Sheild





















1. SDRead Test

2. Play a whole list of files using DAPHC in Examples under WAVE HC
3. Play text to voice using PiSpeak HC or PI Party. They should be the same or similar. You will have to put another set of wav files on the SD card. Here is the zipped file
4. SampleRateHC


11/7 Mini Project 2 - Process 1

The idea for my second mini project is to experiment with the Piezo sensor and detecting vibrations in water. My concept centers on the simple human need for curiosity and experimentation. I will build a bin out of some sort of clear, solid material and place a plastic bag inside. The bottom of the bag will have a thin layer of sand and then filled almost to the top with water.

Beneath the bin, in a special underside section, will be the breadboard with shapes or lines of LED's. On the side of the plastic bag filled with water will be one or two Piezo sensors, which also connect to the breadboard/Arduino. The idea is that the brightness of the LED's will be controlled by the strength of the vibrations of the water, caused by somebody dragging their finger through it. They are required to push and dig through the sand at the bottom to uncover the light from the LED's, which grows stronger the more vibrations they cause.


Mini Project 2 Update 1

Initial kinect integration