# data[].attributes.body
http://www.instructables.com/id/Arduino-Obstacle-Avoiding-Robot-Using-L298N/
This looks like a fun toy to ahve around ur room

# data[].attributes.body
http://www.instructables.com/id/Arduino-Robotic-Arm-Control-With-a-Potentiometer/
This looks like a very useful thing to have in the house and to play with as well

# data[].attributes.body
I think this woul be good because i like music so i would find itr fun

# data[].attributes.attachment_link.readable_text
Introduction: Arduino Xylophone

I made a xylophone that uses an Arduino Mega to detect when a note is struck, and generate MIDI output. This project is wondeful because I essentially made a xylophone, a drumkit, and any other MIDI controlled sound instrument, with one tool. The following steps will outline what I used to make this xylophone.

Step 2: Free the Piezos, Then Solder Longer Leads.

For this project, I used piezo elements to detect when each note is struck on the xylophone. These piezos detect vibration, or a knock. Often the elements come in a housing, to protect the disc from being bent or smashed - but for this project I needed to remove them from their plastic.

By gently pressing around the edges with my fingers, you could hear the glue crack apart from the plastic, I loosened the bottom of the casing. Carefully, I insterted a precision flat-head screw driver, and popped the bottom of the case off.

The piezo element could then be removed from the outside of the housing.

Because I am using an Arduino Mega Board, I could have up to 16 Analog inputs, or 16 Piezos. I decided to just include an octave & a half, 12 notes, so I used 12 piezos.

After they were free from their case, I soldered longer wires to each piezo element, to prepare them to be inserted into the xylophone. When I was done soldering longer leads on to each piezo, I wrapped my solder points with heat shrink or electrical tape.

Step 5: Attach the Bars to the Top Panel.

I used 1 1/2" machine screws and nuts to secure the bars to the wooden paneling.

To prevent excessive shake or vibration on each bar, I decided to use vinyl tubing as a shock absorber on each machine screw. With 12 bars, I used 24 machine screws and nuts, and 24 3/4" lengths of vinyl tubing. Thread the machine screw through the bar, then the vinyl, and slip it into the paneling. When the screw was through the panel, I was able to twist on the nut to fully secure it to the panel.

All of these should only be finger-tight, to avoid stress on the paneling, or on the bar.

Step 7: Connecting to the Arduino

I took all of the signal wires, and the ground wire running from the PCB and marked each one with blue masking tape, writing which port each wire was designated to. I then fed all of the marked single core wire into the corresponding ports of the Arduino.

All remaining Analog ports must be grounded! Otherwise it will affect your serial output from the arduino. I used 4 black wires, running from the ground rail of the PCB directly to the open analog ports of the Mega board. (A12, A13, A14, and A15)

When you have completed your circuit, you can load the xylophone program, or sketch, onto the Arduino board from the Arduino Developing Environment.

Here is the sketch I used.

Step 8: Power and Communication.

The Arduino can be powered via USB, which doubles as a communication port. I ran a USB cable through the housing of the xylophone. By drilling a small hole, that was big enough for the ends of the cable, I could hide most of the USB cord in the housing.

I drilled a second hole to hold my mallots.

Step 9: Serial to Midi

To get the xylophone coupled with my comptuer I used software called Hairless. It converts the serial out signal from the Arduino into a MIDI signal that programs like GarageBand, Logic, and Ableton can read and record. Be sure that the bridge is running before you try and import MIDI data from the xylophone.

Note: Disable the bridge while trying to update the sketch on the Arduino board. You cannot have the bridge running while trying to communicate to the board from the Arduino software.

Step 10: Jam It!

After you are up and running, you can play the xylophone like drums. Record your beat track. Then kick change the MIDI instrument to a bass synth, and record a rhythm track. Finally turn it back into a xylophone and create a melody track for the best song ever. This thing is a lot of fun!

# data[].attributes.attachment_link.description
I made a xylophone that uses an Arduino Mega to detect when a note is struck, and generate MIDI output. This project is wondeful because I essentially made a xylophone, a drumkit, and any other MIDI controlled sound instrument, with one tool. The following steps will outline what I used to make this xylophone.

# data[].attributes.body
I think this would keep me occupied when im bored

# data[].attributes.attachment_link.description
Hello!This My First Instructables.This Is A instructions for a simple Arduino Simon Says Game.Parts needed:220 ohm resistor,4 buttons,4 leds(All in next step.)

# data[].attributes.body
I just think this would be cool and it would keep me safe.

# data[].attributes.attachment_link.readable_text
Introduction: Personal Security System Using Arduino

Here is just a simple guide on how to create your own mini "security system" using an Arduino. This is just a fun project, please don't actually rely on this device to keep your house secure! This design uses an Arduino, a HC-SRO4 Ultrasonic Sensor, a Buzzer, and some LED's. Ultimately from this tutorial, I hope you learn how to use a buzzer and LED's to display how far away an object is from the ultrasonic sensor.

Step 1: Assemble Materials

Materials required are:

(1x) Arduino Uno

(1x) Breadboard

(1x) HC-SRO4 Ultrasonic Sensor

(1x) Buzzer

(1x) Green LED

(1x) Yellow LED

(1x) Red LED

(4x) 220 ohm Resistors

(10x) Jumper wires

Step 2: Setup

The photo above shows the setup of the project.

The circuit should be setup as follows:

Connect a red wire from the 5V pin on the Arduino to the positive channel of the breadboard.

Connect a black wire from the GND pin on the arduino to the negative channel of the breadboard

Buzzer = pin 3

On Ultrasonic Sensor:

Echo = pin 6

Trig = pin 7

LEDs:

RedLED = pin 9

YellowLED = pin 10

GreenLED = pin 11

The green wires connected to the LEDs should be connected in line to the positive side of the LED, while the negative side of the LED should be connected to the negative channel of the breadboard using a 220 ohm resistor.

Step 3: Assembly - Breadboard

Firstly, let's connect the 5V and GND pin on the Arduino to the breadboard. As I mentioned before, be sure that the wire attached to the 5V pin is connected to the positive channel of the breadboard, and the wire attached to the GND pin is connected to the negative channel of the breadboard.

Step 4: Assembly - Ultrasonic Sensor

Time to connect the HC-SRO4 ultrasonic sensor! A great tip is to place the ultrasonic sensor as far right to the breadboard as possible and make sure that it is facing out. Referring back to the setup picture, you should connect the GND pin on the ultrasonic sensor to the negative channel on the breadboard. Next connect the Trig pin on the sensor to pin 6 on the Arduino and connect the Echo pin on the sensor to pin 7 on the Arduino. Lastly, connect the VCC pin on the ultrasonic sensor to the positive channel on the breadboard. Refer to the picture above if anything gets confusing.

Step 5: Assembly - LEDs

The next step is to connect the LED's to the breadboard and Arduino. If you need to, I highly recommend that you refer back to the setup picture (Step 2), attaching the LEDs is pretty easy, there's a lot of repetition. Let's first attach the Green LED. So the way to do this, is to connect the anode (the longer leg) to pin 11 on the Arduino with a green wire, and to connect the cathode (the shorter leg) to the negative channel on the breadboard, using a 220 ohm resistor. Then repeat that step for the Yellow and then the Red LED, make sure to connect the anode (the longer leg) of the yellow LED to pin 10 on the Arduino and then connect the anode of the red LED to pin 9. Once you have done that, your setup should look similar to the picture above.

*NOTE*

Resistors are not absolutely necessary, however they are highly recommended to be used.

Step 6: Assembly - Buzzer

The last part of the setup for this, is connecting the buzzer to the breadboard and the Arduino. This is one of the easiest parts of the whole setup. All that is required to do is to connect the longer leg of the buzzer to pin 3 of the Arduino using a green wire and then connect the shorter leg of the buzzer to the negative channel of the breadboard using a 220 ohm resistor.

*NOTE*

It is HIGHLY recommended to use a resistor in connecting the shorter leg of the buzzer to the negative channel of the breadboard. This greatly reduces the volume of the buzzer and prevent it from dying to quickly.

Step 7: Code

Now that you have finished the setup, its time to code the Arduino. All you have to do, is to open the Arduino program on your computer and then copy and paste the code from below. Feel free to change the distances at which the ultrasonic sensor detects an object from and the volume of the buzzer!

#define trigPin 6<br>#define echoPin 7
#define GreenLED 11
#define YellowLED 10
#define RedLED 9
#define buzzer 3

int sound = 500;

void setup() {
  Serial.begin (9600);
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  pinMode(GreenLED, OUTPUT);
  pinMode(YellowLED, OUTPUT);
  pinMode(RedLED, OUTPUT);
  pinMode(buzzer, OUTPUT);

}

void loop() {
  long duration, distance;
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  duration = pulseIn(echoPin, HIGH);
  distance = (duration/5) / 29.1;

  if (distance < 50) {
      digitalWrite(GreenLED, HIGH);
}
  else {
      digitalWrite(GreenLED, LOW);
  }

  if (distance < 20) {
    digitalWrite(YellowLED, HIGH);
}
  else {
    digitalWrite(YellowLED,LOW);
  }

  if (distance < 5) {
    digitalWrite(RedLED, HIGH);
    sound = 1000;
}
  else {
    digitalWrite(RedLED,LOW);
  }

  if (distance > 5 || distance <= 0){
    Serial.println("Out of range");
    noTone(buzzer);
  }
  else {
    Serial.print(distance);
    Serial.println(" cm");
    tone(buzzer, sound);

  }
  delay(300);
}

Once you've done that, and you've plugged in your Arduino to your computer, run the code and you're finished. If you've followed all the directions properly, the closer your hand or any object gets to the HC-SRO4 ultrasonic sensor, the LEDs should progressively light up until and you're so close that the buzzer will go off.

Step 8: The Working Arduino!

This is a really fun project, I had a lot of fun creating it. I just want to give a shoutout to my Computer Science teacher Mr. Smith for being so very helpful and being amazing!

# data[].attributes.attachment_link.description
Here is just a simple guide on how to create your own mini "security system" using an Arduino. This is just a fun project, please don't actually rely on this device to keep your house secure! This design uses an Arduino, a HC-SRO4 Ultrasonic Sensor, a Buzzer, and some LED's.

# data[].attributes.body
i wouldnt have to worry about forgetting to feed my pets.

# data[].attributes.attachment_link.readable_text
Now that we have the code written, we can connect the Arduino to the servo to test everything out. The connections are as follows:

Black Servo Wire - Arduino GND

Red Servo Wire - Arduino 5v

White Servo Wire - Arduino Pin 13

After you have tested that everything is working properly, you can secure the Arduino in place. My Arduino has a 3D printed case that I made for it. This made it really easy to just hot glue the assembly to the inside if the pet feeder.

Using what was left of the project board, I cut out a back panel for the pet feeder, making sure to leave room for the power cord.

The final modification I made was adding legs to the feeder to raise it up above the pet food bowl. For the legs I cut 4 2" pieces of dowel rod I had laying around. They I hot glued some foam to the bottom of the pieces so they don't scratch the floor. All that was left to do was hot glue the legs to the feeder and...IT'S DONE!

# data[].attributes.attachment_link.description
Now that we have the code written, we can connect the Arduino to the servo to test everything out. The connections are as follows: Black Servo Wire - Arduino GND Red Servo Wire - Arduino 5v White Servo Wire - Arduino Pin 13 After you have tested that everything is working properly, you can secure the Arduino in place.

# data[].attributes.body
just thought this would be cool and fun to use.

# data[].attributes.attachment_link.readable_text
Introduction: Arduino - Line Follower Robot

Arduino Project Tutorial Line Follower Robot - For beginners

In this tutorial, you will make line follower robot.

Step 1: Video Tutorial

This tutorial involves building a line follower robot with an QTR-8RC Reflectance Sensor Array.

Step 2: Hardware Required

Arduino Board

Motor Shield (Adafruit)

QTR-8RC Reflectance Sensor Array (Pololu)

DC Motor x2

Wheel x2

Bovine Wheel

Chassis plate

Battery 9V

Battery Buckle

Wires

Button

Glue Gun

Electrical Tape

Step 3: Create of the Chassis

1. The DC motors attach to the chassis

2. The Arduino attach to the chassis

3. The Motor Shield attach to the Arduino.

4. The Bovine Wheel attach to the chassis

5. Wheels attach to the DC Motors

Step 4: About the Motor Shield

The motor controllers on this shield are designed to run from 4.5V to 25V.

There are two places you can get your motor 'high voltage supply' from. One is the DC jack on the Arduino board and the other is the 2-terminal block on the shield that is labeled EXT_PWR.

To connect a motor, simply solder two wires to the terminals and then connect them to either the M1, M2, M3, or M4.

Step 5: DC Motors and the QTR-8RC Sensor Connections

1. DC Motors connect to the Motor Shield

2. Left Motor connect to M1 - Right Motor connect to M2

3. The QTR-8RC Reflectance Sensor Connections

The Sensor VCC connect to the Arduino +5V

The Sensor GND connect to the Arduino Ground

The Sensor pin 2 connect to the Arduino Analog 0

The Sensor pin 3 connect to the Arduino Analog 1

The Sensor pin 4 connect to the Arduino Analog 2

The Sensor pin 5 connect to the Arduino Analog 3

The Sensor pin 6 connect to the Arduino Analog 4

The QTR-8RC Reflectance Sensor attach to the chassis

Step 6: Battery and on / Off Button Connection

The (+) from the battery is connect to a leg of the button

Connect a cable to the other legs of the button. This cable is for Motor Shield (+)

If you would like to have 2 seperate DC power supplies for the Arduino and motors. Plug in the supply for the Arduino into the DC jack, and connect the motor supply to the PWR_EXT block. Make sure the jumper is removed from the motor shield.

Step 7: Copy the Code and Install the Arduino Libraries

Uncompress the ZIP file onto your desktop

Place the AFMotor folder into your arduinosketchfolder/libraries folder

Rename the uncompressed folder AFMotor

Step 8: If It Helps, Please Subscribe

First of all, I would like to thank you for reading this guide ! I hope it helps you.

If you want to support me, you can subscribe my channel and watch my videos.
Visit My Youtube Channel - Mert Arduino Tutorial & Projects

# data[].attributes.attachment_link.description
Arduino Project Tutorial Line Follower Robot - For beginners In this tutorial, you will make line follower robot. This tutorial involves building a line follower robot with an QTR-8RC Reflectance Sensor Array.

# data[].attributes.body
so i could see waht the time is in a cool way

# data[].attributes.attachment_link.description
This instructable will help you to build an Arduino Binary Clock. The orignial idea for this instructable was designed by Daniel Andrade. My instructable...

# data[].attributes.body
This clock also gives you day, month and year information which you dont always know, but always tend to need.

Jiawen

# data[].attributes.body
Its basically an electric version of a normal xylophone, which you won't really be able to buy. (?) So it's quite unique.

Jiawen

# data[].attributes.body
It is something that can be useful in everyday life, and i just like the idea of being able to make something for yourself to use.

Jiawen

# data[].attributes.body
http://www.instructables.com/id/Arduino-holder/
This is useful if you have an Arduino but don't know where to put it.

# data[].attributes.body
http://www.instructables.com/id/Arduino-Controlled-Line-Following-Robot-1/
It is a useful object which can be used to clean your floors.

# data[].attributes.body
http://www.instructables.com/id/Personal-Security-System-Using-Arduino/
Its very useful in situations where u don't want anyone to come in your room and things like that.

# data[].attributes.attachment_link.readable_text
Introduction: Making Microcontroller Artificially Intelligent - Neural Networks

Artificial Intelligence, one of the most important research topics in computer science and robotics, and all implemented on a single chip that has memory of 8kbytes!? The main aim of this project is to describe possibility of implementing one of the leading algorithms in artificial intelligence that is Neural Networks on tiny microcontroller.

Neural Networks (or Neural Nets for short) is a mathematical object that mimics the behavior of brain through connecting smallest computing units: Neurons. One of the main properties of (artificially) intelligent object is to be adaptive i.e. learn and analyse environmental conditions, and be able to respond to new, previously unseen condition.

This instructable will show you how this can be done on cheap tiny commercially available microcontroller, which I've chosen to be ATTiny85. This microcontroller has 8kbytes of memory and is able to fully run Neural Network with total of 6 neurons which is enough to learn any non-linear correlation of two inputs to single output.

Step 1: Required Parts

The one of the main aspects of artificially intelligent object is to be adaptive to the environmental conditions and be able to learn the data supplied from any arbitrary sensor connected to one of its input ports.

In this project, to make system/circuit autonomous, i.e. independent of computer and simple, there are several components required other than a main microcontroller. General part list for this project has the following form:

1. Main Microcontroller Chip, for e.g. ATTiny85 - The Brain of the circuit

2. 2x Variable resistors (Potentiometers) of any range - Simulating a sensor input

3. Any LED (It's better to use visible light LED :)) - Simulating an output

4. 2x Buttons - One for adding entry in dataset or to the "experience of the brain", and One for training the dataset (more details will be supplied in the concluding steps)

5. Several resistors - For LED, buttons and etc.

6. <0.1uF Capacitors - To avoid bouncing effect of button

Note that this "list" is not universal, that is, it might vary from different applications of the trainable microcontroller, for e.g. one might substitute simple variable resistors with temperature or light sensors, thereby allowing possibility of measuring optimal light-temperature values.

Step 2: The Circuit

Generally, the program consists of two different modes of operation, which I'll from hereafter will refer to as: Training and Acting modes. Due to limited number I/O pins, some pins may represent input pins in one mode whereas in another mode, represent output pins.

The Pinout:

Pin 1: Reset/Clear dataset in both Training and Acting modes.

Pin 2: First analog input of Neural Net in both Training and Acting modes.

Pin 3: Second analog input of Neural Net in both Training and Acting modes.

Pin 4: Ground

Pin 5: Training Mode: Train and Switch mode, Acting Mode: Switch mode

Pin 6: Training Mode: Add current state to dataset, Acting Mode: Output of the Neural Network

Pin 7: Training Mode: Output condition to learn with given inputs, Acting Mode: Not Connected

Pin 8: +5 volts

I will describe the meaning of each pin in the Testing step.

Step 3: The Program

The program serves as the main part of the project: It simulates a brain (with 6 neurons). It allowed the microcontroller to learn from its experience (that is data externally supplied or taught by its user).

You can upload the program using Arduino as a programmer, this can be done as follows:

1. Open File->Examples->ArduinoISP.ino in the Arduino IDE

2. Make sure you have correct port and board selected (Arduino which is to be used as a programmer)

3. Upload the code to your Arduino and disconnect it from your Computer

4. Connect Arduino to ATTiny85 as shown in the image above.

5. Download ATTiny85 board files from: Here

6. Click Shift and upload button as shown on the image

7. Done!

Now you can move on to the next steps, where you'll explore the possibilities of the 6 neurons running on the microcontroller.

Step 4: The Modes of Operation

As mentioned previously, there are two modes of operation: Training and Acting Modes:

Training Mode

When the power is supplied the the microcontroller, it will boot into the Training Mode by default. Here, the PinOut of the microcontroller is:

Pin 1: Reset

Pin 2: First analog input to Neural Network

Pin 3: Second analog input to Neural Network

Pin 4: Gnd

Pin 5: Train and Switch mode

Pin 6: Add to Dataset

Pin 7: Input of the value of the desired Neural network output with the current state of inputs(Pin2 and Pin3)

Pin 8: +5 volts

To better explain the idea behind each pin consider an example: suppose one wants to create a device that can predict whether or not current Light-Temperature values in the current environment are optimal (for e.g.: Not too Hot/Cold and Not too Dark/Illuminated) based on it's experience supplied by the user. To phrase the requirement more concretely: The Output should be at maximum if the environment if not both too Hot/Cold and too Dark/Illuminated, if at least one parameter deviates too much from optimum level, the output voltage should drop. Well to do this, you first teach microcontroller what do you mean under the optimum level, this is done by placing the microcontroller in Dark/Cold room and telling it that this environment is not good, i.e. it should have low voltage on the output pin in this environment. Similarly, in not too Hot/Cold and not too Dark/Illuminated room, the microcontroller is told that it should output the maximum voltage. This process is called training. In this case there are two sensors required: Optical and Thermal. Here temperature sensor might correspond to Pin 2 and the light level(optical) sensor might correspond to Pin 3. Output voltage is supplied to microcontroller through Pin 7 and the desired output voltage is "told" to microcontroller by clicking the button connected to Pin 6. When the learning procedure is done, you can click Train and Switch mode button connected to the Pin 5, which will "train the microcontroller" (I will describe this process in concluding sections) and will switch the current mode, that is Training mode to the Acting Mode.

More formally: In the Training modeone supplies the microcontroller with the input-output correlations through pins:

Input: Pin 2, Pin 3

(Desired) Output: Pin 7

by adjusting the voltages on , Pin 3 and Pin 7 pins, and clicking Add to Dataset button (connected to Pin 6). If the dataset is fully supplied, the Train and Switch mode button (connected to Pin 5) is clicked, thereby switching the current mode, that is Training mode to the Acting Mode.

Acting Mode

After teaching your microcontroller, it must use its current knowledge in real physical situations! This mode makes this possible, specifically, with the current input values (i.e. states of potentiometers) it predicts what the output value (voltage on LED), should be, based on its experience/training data supplied by you.

To better illustrate this, consider previously mentioned example about teaching microcontroller the optimal level of Light-Temperature tradeoff: after clicking the Train and Switch mode button (that is connected to Pin 5), the training process will be initiated, which lasts approximately 20 seconds, after which the mode is switched to the Acting Mode. In this mode the pinout changes drastically:

Pin 1: Reset

Pin 2: First analog input to Neural Network

Pin 3: Second analog input to Neural Network

Pin 4: Ground

Pin 5: Switch Mode

Pin 6: Output/result of the Neural Network based on input pins ( Pin 1 and Pin 2)

Pin 7: No function

Pin 8: +5 volts

Here similarly to the previous mode, Pin 2 and Pin 3 are the sensor (Optical and Thermal) input pins. These are like eyes for us, which sense and give data to us, using which we make a decision according to our experience, that is for example to stop walking when we see an obstacle, similarly, the pins: Pin 2 and Pin 3 are sensor inputs: in the aforementioned case optical intensity and temperature sensors, which supply data in form of voltage, then, the microcontroller using this values and its experience/knowledge decides how optimal current environment is by outputting corresponding voltage on the Output/Result pin (that is Pin 6).

Step 5: Testing the Neural Nets

After completing previous steps the circuit is now ready to be tested. When the microcontroller first powers up, it boots into Training Mode where it is waiting for the data to be supplied. The basic test dataset for learning algorithm is to simulate XOR gate which is a non-linear function of two variables. The output of XOR gate with respect to the values of the input variables is shown in the image above. So now question becomes: "How to train it?". Here're the steps for training microcontroller to simulate the XOR gate:

1. Set the values of variable resistors connected to (Inputs) Pin 2,Pin 3 and (Output) Pin 7 to zero.

2. Click Add to Dataset button (i.e. button connected to the Pin 6).

3. Set the values of variable resistors connected to (Inputs) Pin 2 and Pin 3 to +5 volts and the value of variable resistor connected to (Output) Pin 7 to zero.

4. Click Add to Dataset button.

5. Set the value of variable resistor connected to (First Input) Pin 2 to zero and the value of variable resistors connected to (Second Input) Pin 3 and (Output) Pin 7 to +5 volts.

6. Click Add to Dataset button.

7. Set the value of variable resistor connected to (Second Input) Pin 3 to zero and the value of variable resistors connected to (First Input) Pin 2 and (Output) Pin 7 to +5 volts.

8. Click Add to Dataset button.

9. Click Train and Switch mode button (i.e. button connected to the Pin 5), this will trigger the output LED on.

10. Wait approximately ~12 seconds for the training process to finish.

11. After training process is done, the LED will start blinking for few seconds.

12. Done!

After the training process is done try changing the state of each variable resistor attached to input pins ( Pin 2 and Pin 3) and observe how the output LED changes its light intensity. The intensity of LED at the current moment depends on both: states of the input variable resistors and on its training dataset.

Above you can download Python script, which contains the same implementation of neural networks but provides graphs of change of error as the training progresses and graph of the output itself.

Step 6: Working Principle of Neural Networks Algorithm

Mathematical flexibility of the algorithm is the main property allowing the microcontroller to learn, analyse and act to given/supplied condition. This is done simply by imitating working principles of brain: Neural Network. Now lets abstract this notion of "Brain": Mathematically one can define an object that takes a vector (set of multiple variables) as its input and outputs another vector, where the output vector not only depends in the input vector, but also on its "previous experience" which we have supplied manually.

More rigorously, this object is a multidimensional vector field which maps given vector with some variable coefficients to another, output vector.

But now the question becomes: How to adjust our object, so that its output is tweaked using its experience ? Here consider a simplified Neural Network, which consists of interconnected minimal computational units, commonly referred to as "Neurons".

Using this idea of Neural Network, we can define our mathematical object to be a network of some simple computational units (namely "Neurons") connected with some coefficients, this allows us to define our input and output in terms of such computational units, specifically if an input is a vector of dimension n (i.e. consists of n variables), on the input we can put n neurons and similarly, if an output vector has dimension m, on the output we can put m neurons representing output vector. This gives us two layers: Input and Output layer. Connecting all neurons from input layer to output layer, with some coefficients gives us simplest form of a Neural network, which is shown in above image.

The coefficients (also called "weights") have very important role in defining what the output will look like for the given input. The process of adjusting coefficients in such way that they give correct output for given input is simply called "training", but how does one define what is "correct" output and what is "wrong" ? Initially we have a dataset, which consists of input output pairs, and we adjust coefficients in such way, that the deviation of the output of the neural network for the given input from dataset's input-output pair is as small as possible.

We can define this "deviation" as a function, for example the most simple definition would be the distance between current output and desired output for the given input. Using this definition our goal becomes to find minimum of this function, but how to do this?

Suppose some person won a trip to a mountain, but with one disadvantage: he is left at the top of the mountain and has all required food but no water. So he's standing on a mountain (of height h) admiring the view (and searching for water), when suddenly he saw a small lake, right at the bottom of the mountain, but in which direction would he go? In direction which minimizes his distance to the lake, so that he is as close to lake as possible, or more specifically: he moves in the direction where change of height is negative (i.e. derivative of height with respect to the coordinate of choice is negative).

Morphing this idea to our problem of "how to change our coefficients (where change translates to the direction in the mentioned example) so that the "deviation" function (which translates to height in above example) is as minimal as possible?" allows us to abstract the above example to a multidimensional (i.e. many coefficients) case:

Change coefficients in proportion to how the negative of "deviation" function changes under small perturbation of coefficients (this is known as Gradient Descent method)

One can surely define "deviation function" as an Euclidean distance between the current output and the desired output for the current input, but using this approach, the training process will take a lot of time. Alternatively we can define a function of two variables (for e.g p and q), which has very large value if p and q are distinct, and has very small value if p = q and is defined for all p,q∈R. Here the deviation function is simply an exponential of a squared of a difference between p and q.

We can now apply previously mentioned idea of minimization to this "deviation" function for our "neural network". Computing its derivatives with respect to all coefficients, gives us an information of how these coefficients should change. After several steps of the algorithm, we can define satisfactory value of our "deviation" function, thereby terminate the process and output the resulting coefficients. This ends the training process (This method is commonly referred to as Back-Propagation Algorithm).

# data[].attributes.attachment_link.title
Making Microcontroller Artificially Intelligent - Neural Networks

# data[].attributes.attachment_link.description
Artificial Intelligence, one of the most important research topics in computer science and robotics, and all implemented on a single chip that has memory of 8kbytes!? The main aim of this project is to describe possibility of implementing one of the leading algorithms in artificial intelligence that is Neural Networks on tiny microcontroller.

# data[].attributes.body
Ii want to see how thi would work with the hands clapping

# data[].attributes.body
Matthew Brown
I think this game looks good because its cheap and easy to make and also looks easy and fun to play.

# data[].attributes.body
Matthew Brown
I would like this because it would help me get up on time and i wouldnt sleep in.

# data[].attributes.body
Although this isnt from instrucatbles i say this on the internet and it looked quite cool

# data[].attributes.attachment_link.readable_text
In this article, we are going to make Arduino weather clock which will tell us the time, date, and temperature. The LM35 sensor will give us the temperature, the DS3231 will tell us the date and the time, and we will use the OLED to display the temperature, date, and time.

The components required for this project are as follows

First of all, connect the OLED with the Arduino. The OLED works with the Arduino through the SPI as well as I2C communication but we have connected it using SPI communication. The SPI pins on the Arduino are pin 8, 9, 10, 11, and 13. The connections of the OLED with the Arduino are as follows

Connect CS of the OLED to pin 10 of the Arduino.

Connect DC of the OLED to pin 9 of the Arduino.

Connect RES of the OLED to pin 8 of the Arduino.

Connect D1 of the OLED to pin 11 of the Arduino.

Connect D0 of the OLED to pin 13 of the Arduino.

Connect VCC of the OLED to 5V pin of the Arduino.

Connect GND of the OLED to GND pin of the Arduino.

After that, connect the DS3231 module with the Arduino. The DS3231 module works with the Arduino through I2C communication. The pins for I2C communication on the Arduino are SDA and SCL. Connect the DS3231 module to the Arduino as follows

Connect GND of the DS3231 to the GND pin of the Arduino.

Connect VCC of the DS3231 to 5V pin of the Arduino.

Connect SDA of the OLED to A4 on the Arduino.

Connect SCL on the OLED to the A5 pin on the Arduino.

In the end, connect the LM35 sensor with the Arduino. Connect the left pin of LM35 to 5V on the Arduino, the middle pin to A0 on the Arduino and the left pin to ground on the Arduino.
You can find a full-size schematic here
First of all, we added the libraries for the DS3231 module and the OLED. The Adafruit library for the OLED has more functions as compared to the other libraries used for OLEDs.

#include
#include

Next, we defined the pins where we have connected the DS3231 module and the OLED. The DS3231 module works with the Arduino through the I2C communication so we have used the SDA and SCL pins of the Arduino.
The OLED works with the Arduino through SPI communication. Therefore we initialized the pins 8, 9, 10, 11, 13 which are for the SPI communications. After that, we initialized the LM35 sensor pin and other variables.

DS3231 rtc(SDA, SCL);
#define OLED_MOSI 11
#define OLED_CLK 13
#define OLED_DC 9
#define OLED_CS 10
#define OLED_RESET 8
Adafruit_SSD1306 display(OLED_MOSI, OLED_CLK, OLED_DC, OLED_RESET, OLED_CS);
const int sensor_pin = A0;
float temp;
float output;

In the setup function, we declared the LM35 sensor pin as input because the Arduino will take the input from the sensor. Then we gave the command to DS3231 and OLED to start communicating with the Arduino.

pinMode(sensor_pin,INPUT);
rtc.begin();
display.begin(SSD1306_SWITCHCAPVCC);

The below lines are commented in the code but if you are using the DS3231 module for the first time and you want to set the day, date, and time, then uncomment these lines and set it.

  //rtc.setDOW(WEDNESDAY);     // Set Day-of-Week to SUNDAY
  //rtc.setTime(19, 02, 0);     // Set the time to 12:00:00 (24hr format)
  //rtc.setDate(7, 12, 2017);   // Set the date to June 6th, 2017

Then we printed the "weather clock" on the OLED for 5 seconds.

  display.clearDisplay();
  display.setTextColor(WHITE);
  display.setTextSize(2);
  display.setCursor(0,0);
  display.print("  Weather ");
  display.setCursor(0,17);
  display.print("  Clock ");
  display.display();
  delay(5000);

In the loop function, we read from the LM35 and calculated the temperature. Then we get the time and date and printed on the OLED.

 output = analogRead(sensor_pin);
  temp =(output*500)/1023;
  display.clearDisplay();
  display.setTextSize(2);
  display.setCursor(20,0);
  display.print(rtc.getTimeStr());
  display.setTextSize(1);
  display.setCursor(0,15);
  display.print(rtc.getDateStr());
  display.setTextSize(1);
  display.setCursor(70,15);
  display.print(rtc.getDOWStr());

Full Arduino Code

#include
#include
DS3231 rtc(SDA, SCL);
#define OLED_MOSI 11
#define OLED_CLK 13
#define OLED_DC 9
#define OLED_CS 10
#define OLED_RESET 8
Adafruit_SSD1306 display(OLED_MOSI, OLED_CLK, OLED_DC, OLED_RESET, OLED_CS);
const int sensor_pin = A0;
float temp;
float output;

void setup()
{
  pinMode(sensor_pin,INPUT);
  rtc.begin();
  display.begin(SSD1306_SWITCHCAPVCC);
  //rtc.setDOW(WEDNESDAY);     // Set Day-of-Week to SUNDAY
  //rtc.setTime(19, 02, 0);     // Set the time to 12:00:00 (24hr format)
  //rtc.setDate(7, 12, 2017);   // Set the date to June 6th, 2017
  display.clearDisplay();
  display.setTextColor(WHITE);
  display.setTextSize(2);
  display.setCursor(0,0);
  display.print("  Weather ");
  display.setCursor(0,17);
  display.print("  Clock ");
  display.display();
  delay(5000);
}

void loop()
{
  output = analogRead(sensor_pin);
  temp =(output*500)/1023;
  display.clearDisplay();
  display.setTextSize(2);
  display.setCursor(20,0);
  display.print(rtc.getTimeStr());
  display.setTextSize(1);
  display.setCursor(0,15);
  display.print(rtc.getDateStr());
  display.setTextSize(1);
  display.setCursor(70,15);
  display.print(rtc.getDOWStr());
  display.setTextSize(1);
  display.setCursor(20,25);
  display.print("Temp: ");
  display.print(temp);
  display.print("C");
  display.display();
  delay(1000);
}

# data[].attributes.attachment_link.title
Arduino OLED Temperature Display with Real Time Clock

# data[].attributes.attachment_link.description
In this article, we are going to make Arduino weather clock which will tell us the time, date, and temperature. The LM35 sensor will give us the temperature, the DS3231 will tell us the date and the time, and we will use the OLED to display the temperature, date, and time.

# data[].attributes.body
Arduino - Security Panel System With Using Keypad and LCD Display

This is very cool and invotate and who wouldnt want something like this

# data[].attributes.attachment_link.readable_text
The Arduino's +5V and GND will be connected to the pin of the breadboard

The LCD has 16 pins and the first one from left to right is the Ground (GND) pin

The second pin is the VCC which we connect the +5V pin on the breadboard.

Next is the Vo pin on which we can attach a potentiometer for the contrast of the display

The RS pin will be connected to the A0 pin of the Arduino.

The RW pin will be connected to the GND pin of the breadboard.

The E pin will be connected to the A1 pin of the Arduino.

The D4 pin will be connected to the A2 pin of the Arduino.

The D5 pin will be connected to the A3 pin of the Arduino.

The D6 pin will be connected to the A4 pin of the Arduino.

The D7 pin will be connected to the A5 pin of the Arduino.

The A (anode) pin will be connected to the +5V pin of the breadboard.

The K (cathode) pin will be connected to the GND pin of the breadboard.

The potentiometer's other pins will be connected to the +5V and GND pin of the breadboard.

# data[].attributes.attachment_link.title
Arduino - Security Panel System With Using Keypad and LCD Display

# data[].attributes.attachment_link.description
The Arduino's +5V and GND will be connected to the pin of the breadboard The LCD has 16 pins and the first one from left to right is the Ground (GND) pin The second pin is the VCC which we connect the +5V pin on the breadboard.

# data[].attributes.body
this is very practical as I'm allways wondering what the temperature  by knowing this I can avoid colds

# data[].attributes.body
Arduino Segway
this just is quite interesting really

# data[].attributes.headline
Arduino - Turn ON Your LEDs and Lamps With a Clap (Relay … i would like to see how this would work with the robotic hands if I could get them to clap then I could turn on lights with my phone

# data[].attributes.subject
Arduino - Turn ON Your LEDs and Lamps With a Clap (Relay … i would like to see how this would work with the robotic hands if I could get them to clap then I could turn on lights with my phone

# data[].attributes.body
Chiagozie

# data[].attributes.body
Arduino Candygrabber

I think that this is very cool and it is something that any kid wants

# data[].attributes.attachment_link.readable_text
Now that we have our socket ready we can get down and dirty with the ActionScript 3.0 code. You can download the code at the end of this step.After giving it a lot of thought I decided not to go to detail and explain how I wrote the class and what it does. The scope of this instructable is not to teach you about classes, design patterns and OOP(object oriented programming). I'll rather focus on how to use it. When I started coding I decided to use a MVC (Model/View/Controller) design pattern for the class and as it grew a realized that maybe it wasn't the best idea and that I should have used another more simple and scalable design pattern. But being eager to continue with the project I decided to stick to it. Don't worry the class will work anyway. I'll be posting the new classes as soon as I finish them.

So open Flash and create two new flash files. One as ActionScript 3.0 and name it Client.fla, and the other for Adobe AIR with the name ArduinoAIR.fla. Then create two ActionScript files and call them ClienDocument.as and ArduinoAIRDocument.as .The client contains a TextArea component named "msgArea", InputText component named "inputMessage", two buttons component named "sendButton" and "reconnectButton", three slider components called "motorX", "motorY", "motorZ", and four dynamic TextFields called "red5StatusTxt", "sharedStatusTxt","socketStatusTxt" and "queueStatus".
The AIR app has the same components, except it also has one extra button component called "sendArduinoButton". When you have these set up you have to point each flash file to it's document class. Document classes in plain terms are used to move your code from the timeline to an external acrionscript file. So for the Client.fla the document class should be ClientDocument.as, and for ArduinoAIR.fla should be ArduinoAIRDocument.as .OK. Now open ClientDocument.as and lest see what we've got here.

In the first few lines we're defining the classes we're going to use.
The things we are interested are inside the public funcion ClientDocument() so lets go through each of them and explain what they do.

The first three lines hide the TextAreas and winner trophy. The 4. line initializes the Red5Broadcast class that handles the streaming and broadcasting of the video. We have to give it the location of the red5 server, the red5 application name and the TextField in which the stream status is displayed. Then we have to add it to the display list otherwise it wouldn't show the video stream.
Next, Flash communicates with the php socket over an XMLSocket class that is part of flash. I created a Model class that will handle all the necessary listeners and dispatch events when the data is received. It is called XMLSocketModel and we initialize it this way:

We have to pass the URL where is our socket, our socket number, and as the last parameter the app type. The URL I use is arduinoproject.no-ip.org . Yes I use www.no-ip.org service. This way I have the possibility to have a hostname for my dynamic IP. Just register, pick a host name and install their program on your computer. The last thing we pass is "client" because we are now working on our client flash file. Note that all of the parameters must be filled in.

The next line initializes the View class. It is used to display the incoming data and it changes when it receives the events dispatched from the Model class.

When we initialize the xmlSocketView we pass to it the TextArea called "msgArea" as a parameter. That tells it where to display our incoming data. The next line tells which Model it should listen for events.

xmlSocketView.socketsModel = xmlSocketModel;

So xmlSocketView should listen xmlSocketModel for events.

Next we have to initialize our Controller class. This is where all of the magic happens. The Controller class is where all the decisions and are made and all of the command are issued. Also the buttons that we put on the stage are going to have listeners in the controller firing commands when we press them, the controller also changes when it receives the events dipatched from the Model class. So, first we initialize the Controler. In the next line we tell it which Model it should listen to. Again as with the View class we tell it the Model is xmlSocketModel .Then we tell it that it's videoBroadcast = broadcast . We add the buttons, the "queueStatus" TextField for displaying the queue, the "winnerStamp" MovieClip that shows if the client wins.
Finaly we initialize the sharedObject which will exchange the commands for the motor with the AIR app. The parameters are your domain path, the name for the shared object and the "sharedStatusTxt" TextField where the status of the shared connection is displayed.

Now we're going to take a look at the code for the AIR app.

Take a careful look at public function ArduinoAIRDocument().

The code is almost the same as in the client flash file except when we initialize the xmlSocketModel class we have to pass "AIR" as the last parameter.

The new thing that we have here is happening in lines 8 through 10.

Here we initialize the socketModel. The socketModel is the Model class for communicating with arduino. It uses flash's Socket class. Line 9 initializes the socketView which is the View class for the socketModel. When we initialze it we have to pass the TextArea "msgArea" because that is also where we'll display the commands we send to arduino and what arduino returns to the AIR app. Line 10 tells the socketView to listen for events from the socketModel.

The xmlSocketAppController extends from the xmlSocketController so we initialize it almost the same way.

The last three lines of code initialize the socketAppController which is the controller for the socketModel. It will handle the communication between the AIR app and arduino through port 5333. Port 5333 will be opened by TinkerProxy.

Now we have to publish our files. Publish the Client.fla for Flash Player 10 and the AIR app.

# data[].attributes.attachment_link.description
Now that we have our socket ready we can get down and dirty with the ActionScript 3.0 code. You can download the code at the end of this step.After giving it a lot of thought I decided not to go to detail and explain how I wrote the class and what it does.

# data[].attributes.body
NFC Habit Tracker "Dory" - Arduino Wearable, Gadget

I think that this is a good idea as if you are very forgetful this could really help

# data[].attributes.attachment_link.readable_text
For this project I used ready made NFC readers with libraries that communicate with them. I also emphasized importance on battery saving by design circuit and code so that gadget can last a long time, unfortunately, ready-made NFC readers are not very battery efficient.
EPROM
Another interesting feature is that we gave these gadgets to people to use them and to test them, so we wanted to collect statistics on their use for this purpose we used Arduino built-in EPROM non-volatile memory. It will persist also after battery is disconnected https://www.arduino.cc/en/Reference/EEPROM

Depending on how many times you power down Arduino in between EPROM writes it can last up to 100000 write cycles, but it could be also much less: http://forum.arduino.cc/index.php?topic=902.0

ATmega328 have following memory:

Flash 32k bytes (of which .5k is used for the bootloader)

SRAM 2k bytes

EEPROM 1k byte

If you want much safer persistent memory I advise using FRAM modules: https://www.adafruit.com/product/1897
Interrupts
An interesting thing about interrupt PIN numbers is that they are not the same as PIN numbers for digitalRead(PIN) etc. It is the case for many micro-controllers. In my case, I programmed it so that when INPUT_PULLUP button gets grounded Arduino is woken up from sleep mode (battery saving mode).

For example:

//INT0 = PIN 2

attachInterrupt(0, wakeUpFunction, LOW);

Or you could use function digitalPinToInterrupt(pin)

attachInterrupt(digitalPinToInterrupt(pin), wakeUpFunction, LOW);
https://www.arduino.cc/en/Reference/AttachInterrup... LED PWMs to control brightness
For controlling brightness of LEDs and intensity of vibration motor, I used PWM function. To control it you can use analogWrite(PIN, Level) on digital pins that support PWM, see picture added to this step.
Source code
Library for making easy low power modes and interrupts: https://github.com/rocketscream/Low-Power

Library for making EPROM permanent memory operations easy: https://github.com/thijse/Arduino-EEPROMEx

Library for SeedStudio 125Hz mini NFC reader (rectangular gadget): https://github.com/Seeed-Studio/RFID_Library . Caution! I modified and included it in github in order to optimize battery performance.

Library for NFC module V3 (rounded gadget): https://github.com/adafruit/Adafruit-PN532

Source code of both gadgets available in GitHub: https://github.com/evaldsurtans/dory-nfc-arduino-t...

# data[].attributes.attachment_link.description
For this project I used ready made NFC readers with libraries that communicate with them. I also emphasized importance on battery saving by design circuit and code so that gadget can last a long time, unfortunately, ready-made NFC readers are not very battery efficient.

# data[].attributes.body
Arduino Violin

I think that this is a good idea as a violin is very expenisive but this is quite cheap and easy to make

# data[].attributes.attachment_link.readable_text
During a FabLab introduction week we got the assignment to build an Arduino instrument. We chose to make a violin.

The original plan was to use a mouse sensor like we saw here: http://moddersandrockers.com.
We tried this and destroyed three mice but to no avail. Finally we settled for just using the mouse's scroll wheel to slide the fiddlestick over. We then used three buttons and combinations thereof to choose a tone. By sliding over the wheel the violin produces sound.

Using Pure Data we channeled the serial read from the Arduino to Midi-notes in Ableton Live. There we coupled the incoming midi-notes to sounds.

The violin body was build using a laser cutter, for the top and bottom, and mill for the thickness.

You can download all required files here: http://jorgoscoenen.be/arduino-violin.zip

# data[].attributes.attachment_link.description
During a FabLab introduction week we got the assignment to build an Arduino instrument. We chose to make a violin. The original plan was to use a mouse sensor like we saw here: http://moddersandrockers.com. We tried this and destroyed three mice but to no avail.

# data[].attributes.body
Arduino - Turn ON Your LEDs and Lamps With a Clap (Relay and Sound Sensor)

I think thaT THis is a good idea as if you have your hands full you can just clap (somehow) and tada the light turn on

# data[].attributes.attachment_link.readable_text
The HIGH Voltage part we need a power plug, a socket and a cable with two wires.

One of the two wires will be cut and connected to the common and the normally open pin of the module output connector.

The Relay VCC pin will be connected to the +5V pin of the Arduino.

The Relay GND pin will be connected to the GND pin of the Arduino.

The Relay INPUT pin will be connected to the Digital 5 pin of the Arduino.
Connection of the Sound Sensor
The Sound Sensor VCC pin will be connected to the +5V pin of the Arduino.

The Sound Sensor GND pin will be connected to the GND pin of the Arduino.

The Sound Sensor OUT pin will be connected to the Digital 4 pin of the Arduino.
Connection of the LED Strip and Adapter
The LED strip possitive cable will be connected to the COM input of the Relay.

The Adapter possitive cable will be connected to the NO input of the Relay.

The LED and Adapter ground cable will be connected together.

# data[].attributes.attachment_link.title
Arduino - Turn ON Your LEDs and Lamps With a Clap (Relay and Sound Sensor)

# data[].attributes.attachment_link.description
The HIGH Voltage part we need a power plug, a socket and a cable with two wires. One of the two wires will be cut and connected to the common and the normally open pin of the module output connector. The Relay VCC pin will be connected to the +5V pin of the Arduino.

# data[].attributes.body
Arduino Parking Assistant

I think that this is a good idea as his is something that can help normal people as well as people with disabilities.

# data[].attributes.attachment_link.readable_text
Mount the sensor on your garage wall where it can sense a flat surface on your car's bumper, not the grill! Mount the control box higher up where it's visible from inside the vehicle.

Park your car in the best position, and use a long object like a pencil to push the button on the bottom. This will calibrate it. The LEDs will begin lighting one by one to give to you time to move aside. Be sure to give the sensor a clear view to the car! The LEDs will flash green to indicate a successful calibration. Red means it couldn't sense anything within range.

When you drive into your garage, slowly approach the parking assistant; the green LEDs show your distance to the ideal parking spot, red shows you when to stop to park in the perfect position!

--------------------------

I had a lot of fun making this project, and I've found it to be really handy! I'd love to see your versions! Feel free to comment with ideas, thoughts, or even your own version. All feedback is welcome!

# data[].attributes.attachment_link.description
Mount the sensor on your garage wall where it can sense a flat surface on your car's bumper, not the grill! Mount the control box higher up where it's visible from inside the vehicle. Park your car in the best position, and use a long object like a pencil to push the button on the bottom.

# data[].attributes.body
It is useful for people who cannot afford to care for a pet. http://www.instructables.com/id/Twitch-Your-Robotic-Pet/

# data[].attributes.headline
Toaster Automation using relay/contactor-powered socket (similar to Jiawen's idea)

# data[].attributes.subject
Toaster Automation using relay/contactor-powered socket (similar to Jiawen's idea)

# data[].attributes.body
Again practical for a person who is too tired to make breakfast.
http://www.instructables.com/id/Automatic-ONOFF-Socket/ +1 toaster

# data[].attributes.body
Based on a popular sci-fi movie or TV show (in this case, star wars). With cool blinky LED's etc. It is very slightly practical, and is also unique.
http://www.instructables.com/id/Talking-Darth-Vader-Binary-Clock/
http://www.instructables.com/id/3-Digit-Arduino-Binary-Counter/

# data[].attributes.body
pretend being able to draw with you own eye
http://www.instructables.com/id/The-EyeWriter-20/

# data[].attributes.body
http://www.instructables.com/id/Arduino-Robotic-Arm-Control-With-a-Potentiometer/http://www.instructables.com/id/Arduino-Robotic-Arm-Control-With-a-Potentiometer/
This looks like a good use and a fun item to have

# data[].attributes.body
Angus
This interested me bc it's useful in some ways such as in a storage compartment for stationary but as well as a decoration for ur room

# data[].attributes.body
this is the perfect underwater, swimming snake toy to scare someone
http://www.instructables.com/id/Make-a-swimming-Robo-Snake/

# data[].attributes.body
Angus

# data[].attributes.headline
I like music and a robotic drum sounds interesting

# data[].attributes.subject
I like music and a robotic drum sounds interesting

# data[].attributes.body
http://www.instructables.com/id/Arduino-Controlled-Robotic-Drum
ojas

# data[].attributes.attachment_link.readable_text
Introduction: Arduino Pong

This Instructable is based on a how-to written by James Bruce:
http://www.makeuseof.com/tag/how-to-recreate-the-c...
Note: This project will not work with the Arduino Yún. An Arduino Uno, Nano or one with a similar architecture is advised.
The requirements:
1x Arduino (I used the Uno. Again, the Yún won't work)

1x 470 ohm resistor

1x 1k ohm resistor (I used a 1.1k ohm resistor)

1x Jumper wire

2x 10k ohm Potentiometer

1x RCA video cable

1x Pushbutton

1x 10k ohm resistor

Share

Recommendations

Water Contest

Oil Contest

Clocks Contest

Step 1: Download the TV Out Library

You can download the library (TVoutBeta1.zip) from here:
https://code.google.com/p/arduino-tvout/downloads/...
You'll want to unpack the .zip file and copy the resulting folders to either Program Files (x86)/Arduino/libraries or Documents/Arduino/libraries.

Step 2: The RCA Cable

Take on end of the RCA cable and strip the outer layer away. Gather up the shielding, twist it and put it away to one side. This is your ground. In the centre should be another cable with some plastic shielding around it. Strip this away as well. This is your signal line. Next you'll want to take your 470 ohm and 1k ohm resistor and solder them both to the signal line. Plug the 470 Ohm resistor into pin DO7 on your arduino and the 1k resistor into pin DO9. This will produce the analogue video input. After that you can take the jumper wire and solder it to the shielding outside of the RCA. This jumper wire needs to be plugged into one of your Arduino's GND pins. If you want you can test TV Out by loading in an example in the Arduino IDE (File>Examples>TVout>DemoPAL or DemoNTSC depending on your region)

Step 3: ​The Potentiometers

Each potentiometer should have 3 pins. The middle one needs to be connected to either A0 or A1 on your Arduino. One of the side pins (it doesn't matter which) should be connected to +5V and the other to GND. You can find a full Fritzing diagram and some pictures above. You can once again test this if you want by using an example from the Arduino IDE (File>Examples>Analog>AnalogInput)

Step 4: The Start Button

Next you'll want to wire a pushbutton to pin DO2. Again, a diagram and pictures can be found above.

Step 5: ​The Pong Code

You can download the Pong code (written by Lamonica and modified by duboisvb) from this pastebin:
http://www.pastebin.com/Su0wdEKG

Step 6: ​Have Fun!

That's everything. Pong is obviously a very simple game but you should still be able to get some fun out of it. If you want to speed the game up a bit try changing the 3 in if(frame % 3 == 0) to a 2 or even a 1. Credit goes to Alex in the comment section of the original how-to article for that one.

# data[].attributes.attachment_link.description
This Instructable is based on a how-to written by James Bruce: http://www.makeuseof.com/tag/how-to-recreate-the-c... Note: This project will not work with the Arduino Yún. An Arduino Uno, Nano or one with a similar architecture is advised. The requirements: 1x Arduino (I used the Uno.

# data[].attributes.attachment_link.readable_text
Introduction: Arduino Calculator

In this Instructable I will show you how to make an Arduino calculator that is just as good as any other calculator (well... sort of). Even though it's probably not practical due to it's size, repetitive use of the equals button (due to the lack of keys), and cost (You can probably buy a calculator that does the same thing for $2), It is really fun and adds a few skills to your inventory. Let me tell you how I got started on this project. It all starts at school where the original calculator was made by my friend/teacher Gabe. If your curious how the old version looked click here. Soon enough students began to play with it and soon broke it. I was the only student who knew how to fix it so I decided I might as well try. In the process I basically took the whole thing apart and started from scratch. I also rewrote most of the code. I learned alot, spent lots of time debugging, and added many new features. In the end it was a project definitely worth doing. The good thing is that now that I figured it out you don't have to. Let's get started.

Step 1: Tools and Materials

For this project we will need:

- 1/8" MDF or other laser cuttable material such as acrylic or plywood
-Laser cutter (optional but recommended)
-Wood glue
-Male to male wires
-Many male to female wires
- 8 by 2 LCD screen
- Keypad
-Drill
-Drill bits
-Disc grinder (optional)
-Switch (rocker or toggle)
-Heat shrink tubing
-Soldering iron and solder
-Screws
-USB A to B cable (cable differs between arduino models)
-Computer with arduino IDE

- 9v battery power plug

-Arduino (I used a duemilanove if you don't want to spend $30 on one search it on ebay)

Step 2: Making the Case

My case was laser cut (I will attach files below in PDF format) from 1/4" MDF but that's because I couldn't find any 1/8" material. The calculator edges look weird because I used the wrong thickness of material. You may be wondering why the box fits together perfectly in the picture above and that's because that box is a completely different cutting designed for 1/4" material. The box doesn't include holes for the LCD or keypad due to variety. That's where the drill comes in. Let me just clear this up one last time USE 1/8 INCH THICK MATERIAL.

Step 3: Drilling and Further Assembly

Lay down the keypad and LCD screen where you want them and use a pencils to mark where the holes are. Find a drill bit that fits the correct size and make the hole. Before screwing in the keypad or LCD holes must be made for the wires to the arduino. To do this you an either modify the laser cut or drill a few holes in a row with a wide enough drill bit and then act like a manual CNC machine pushing the drill sideways toward the other holes until you connect them by routing through. Once this is done connect the wires and to the components and screw the LCD and Keypad into place. Now use the wood glue to glue all of the cut pieces together, you might want to leave the top open for maintenance (trust me don't glue on the top until you are done). If you want to you can use a disc grinder to sand down the edges. You might notice in my laser cut I added an access hatch on the back to make the calculator accessible if broken (Got that idea so I wouldn't have to start over again if the calculator broke).

Step 4: Hatch Support

So now we have to create 3 square brackets (fourth can't be mounted due to on/off switch) to hold the hatch in place. To make ours just cut a 2 by 4 with a hack saw into small triangles. If they are too small, they will split but if they are too big they take up lots of room. Use your best judgement. Once done, drill holes into the sides to create guide holes for the screw. Align the triangles so that they fit into the corners with one side ready to be screwed into the side of the case and one side facing toward the back of the case. Add the back plate and screw through it into the DIY brackets. Once done remove the hatch so we can access the arduino and add code.

Step 5: Power

On the side of the case I have a hole where the 9v battery and switch are accessible. Cut the positive side of the 9v power plug with wire strippers and strip off the ends. Solder one side of the the wire to the left pin on the switch, and the other to the center pin on the switch. Wrap with heat shrink tubing then plug the 9v clip into the battery and the plug into the arduino. Look for short circuits, then test the switch. Screw the switch into place. If needed, add guide holes to direct the screw. If you want to label the on and off sides off the switch you can use a label maker or hand write it. Finally, I screwed a small scrap piece of plywood to the back of the case to make sure the battery stayed in place. Don't worry about of the rest of the wiring yet, we are going to cover that in the next step.

Step 6: Wiring

Before I start this step let me apologize for the wiring mess (that's why I included a table). As you can see in the photos above there will be lots of wires floating all over the place. I highly recommend you use a label maker or a piece of tape to mark the pin each wire is supposed to attach to. Most of the wires I used were male to female but I did use some male to male wires for power which you will read about below. If you have a different LCD screen or Keypad it doesn't matter as long as the code is changed accordingly and the arduino has enough spare wires. Here are links to the datasheets of the components I used LCD, Keypad.

In an attempt to preserve the longevity of the calculator I glued all of the wires to the arduino once attached and glued the arduino to the case. If you look closely at the photos you can see I had to use some protoboard to hook all of the 5v connections together and all of the Ground connections together. Basically this is just a few wires soldered to a protoboard and solder bridged together. Note: One half of the board for ground connections and one half for 5v connections.

Step 7: Code

The code can be found somewhere in this step as both a zip file and ino file. It is about 480 lines long but it is all simple code for the most part. A few special features of the code is that it will create an error if a number is divided by 0, It calculates trigonometry functions in degrees rather than radians, After the equation is completed any key can be pressed to clear, A number can be made negative easily, and decimals are handled well. If you get the zip, extract it then open the file in the arduino IDE. If you downloaded the ino, open it with the arduino IDE and it will ask you if you want to create a folder for it just say yes and it should work. Once you have it opened, choose your board, plug the board in, and upload the sketch.

Step 8: How to Use

Due to the fact that the the calculator only has a few keys that aren't numbers, I devised a system to utilize the few keys I had available to allow the calculator to function normally. First I am going to explain in words how it works then I will pretend to do a problem and write down all of the keys I pressed in order.

(1) Select a number on the keypad (2) use A and B to scroll to the function you want (3) once on the function you want hit D or = (4) What you have so far should jump to the top line, now select your second number (5) Hit D or =(6) The equation should move to the top line leaving your answer on the second line

Example: 2 A A (hitting a twice will scroll to -) D 1 D (Done)

# data[].attributes.attachment_link.description
In this Instructable I will show you how to make an Arduino calculator that is just as good as any other calculator (well... sort of). Even though it's probably not practical due to it's size, repetitive use of the equals button (due to the lack of keys), and cost (You can probably buy a calculator that does the same thing for $2), It is really fun and adds a few skills to your inventory.

# data[].attributes.body
http://www.instructables.com/id/Garden-Arduino-Lights/ These are good to light up your garden

# data[].attributes.body
http://www.instructables.com/id/Arduino-controlled-Fox-Away/ This is handy for me because I  have rabbits and its always the worry that they might get hurt by foxes

# data[].attributes.body
http://www.instructables.com/id/Arduino-Smart-Dryer/ This would be good to use if u needed to dry something quickly and fast

# data[].attributes.body
a violin made using sensors and arduino instead of strings

# data[].attributes.body
a gimbal for cameras to keep stable

# data[].attributes.body
if you have a rocket you can give it a flight path using this i think

# data[].attributes.body
http://www.instructables.com/id/The-Magic-Mirror/
this would be a useful thing to have, it would be interesting to see how it is made

# data[].attributes.body
http://www.instructables.com/id/Lilypad-Arduino-Light-up-Critter/
this would be good to see how light up toys do work.

# data[].attributes.body
http://www.instructables.com/id/Arduino-Smartphone-Controlled-Arduino-Robot-Car-Vi/
i would like to do this as i am good at doing things on my phone

# data[].attributes.body
because this looks really cool and fun

# data[].attributes.body
An auduino enigma machine, so i can stop the USA Spying on me. Also practical as an example to show others.

# data[].attributes.body
I like the idea of a tropical theme based music speaker like these coconut speakers:
http://www.instructables.com/id/Coconut-Speaker-2/

# data[].attributes.body
Auduino bank
For making me money and allowing me to loan more easily.

# data[].attributes.body
http://www.instructables.com/id/SpeechVoice-Controlled-Arduino-Drone/
its prty peng and cuel as in u can use ur voice

# data[].attributes.body
a candy grabber grabberhttp://www.instructables.com/id/Arduino-Candygrabber/
we are doing this becasue we are lovers of sweets

# data[].attributes.body
http://www.instructables.com/id/Smart-Pantry/
Smart pantry
I like that as you can control it using an android app  and therefore looks very good

# data[].attributes.body
Hunter, Arduinio Game.
I want to see if this works and how accurate. Id also like to know how hard it is and how well developed it is.

# data[].attributes.body
http://www.instructables.com/id/Arduino-Turn-ON-Your-LEDs-and-Lamps-With-a-Clap-Re/
This is a very nice project for if you ever wake up and just want to start reading you can clap your hands and the lights will automatically turn on.

# data[].attributes.attachment_link.readable_text
Once you have decided how big your airplane is going to be, start by choosing a proportional propeller. By proportional I mean you don't want to choose too big or small prop for your airplane.

Now, determining the size of propeller sure requires some maths. But you do not need to worry about determining prop size unless you want to design your own RC airplane. Anyways, you can always use e-calculators.
I used eCalc to determine the size of propeller.

This airplane has a wing span of 20 inches that requires a 5-6 inch prop. Now, I think 5-inch prop works best. Where 5 inch is the diameter of the propeller. Also, the airplane is for beginners and we do not want a massive amount of thrust. So, we'll use a 5.0-inch prop with a 3.0-inch pitch.
What do the numbers on a propeller mean?
Suppose a propeller is labeled a X b. Here, 'a' represents the diameter of the propeller in inches and b represents pitch of the propeller in inches. Where pitch is the distance that the propeller is going to move forward during one revolution ( Under perfect conditions).

So for this airplane, we will use a 5.0 X 3.0 propeller. Simply, a 5030 propeller. Combine this propeller with a powerful motor to meet the thrust to weight ratio.
Thrust to weight ratio?
Well, keeping the weight of the airplane you are building in mind, you need to supply a motor and prop powerful and big enough to pull your airplane into the air. Typically it's 1:1 normally to 1:4 for slow-flyer. For example, if your airplane weighs 400 gm. For, 1:1 thrust to weight ratio you need a motor and prop producing a minimum thrust of 400 gm.

Once you know the average weight of your airplane, look for a motor and propeller combination that at least meets 1:1 thrust to weight ratio. If the design of airplane is efficient enough, it flies great even with a small amount of thrust. But, remember this was just a general statement to give an idea of thrust to weight r atio.

Motors
Type of motors used on RC airplanes:
We use brushless motors in RC airplanes these motors are highly efficient and are lightweight as compared to brushed motors. Brushless motors are classified on the basis of their size and rotational speed.
What does the numbers on a motor mean?
The first set of number is a 4 digit number or 2 two digit numbers separated by a dash "-". The first two digits number is diameter (in mm) and the second two digits number is the height of the motor (in mm).

The second set of numbers represents KV. Or, at how many RPMs the motor is going to rotate when powered through 1V. So, if you have a 2280 KV motor running at 11.1 Volts your motor is running at 2280 X 11.1 = 25308 RPM.
Choosing the motor:
With the battery and electronics our airplane will weigh about 290 grams. So, we'll be using a EMAX MT1806 2280 KV brushless motor. This motor produces 380 grams of thrust with 5030 prop at 11.1 Volts. This amount of thrust is good enough for this design. ( In the build I'm using the same motor from a local manufacturer.)
Find how much thrust your motor produces:
Motor manufacturers provide datasheets along with the motors. Here you can find how much thrust your motor is going to generate with a particular propeller and battery. Refer to the datasheet of EMAX MT1806 here.

ESC

Moving on to powering the motor, Brushless motors require ESCs or, Electronic Speed Controller that converts DC current from your battery to AC current going to your motor because, Brushless motors operates on AC current.

ESC also controls the speed of motor through its servo lead and provides 5V DC power for your receiver that controls all your electronics. Now, ESCs are able to provide 5V DC power for radio receiver using a BEC or a Battery Elimination Circuit . So, that you do not need two separate batteries for your motor and your radio receiver.
Choosing ESC:
ESCs are classified on how many amps. of current they are going to supply to your motor. So, an ESC that's rated 10 A is going to supply a maximum of 10 A current to your motor (Safely). Once you know which motor and propeller to use, refer to the datasheet of your motor and find out how much current your motor is going to draw.

Now, for safety reasons we always choose an ESC that's rated 5-10 amperes more than the requirement of a motor at full throttle. This will make sure that the ESC is running cool and you don't need to worry about heating inside your airplane.

By referring to the datasheet provided for EMAX MT1806, I found that the motor will be drawing 8 A of current from the ESC when working with 5030 prop and 3s li-po battery at full throttle. Considering safety for ESC and to run it cool we'll be using a 20 A ESC.

Battery

Now, as already mentioned we'll be using a 3s li-po battery. Also, we do not want to make our airplane heavy. So, use a 1000mAh 30C 3s li-po battery. Li-po batteries are rechargeable batteries that require a special charger for battery's long life called a Balance Charger. Any other attempts of careless charging can not only damage your battery. But, can even lead to explosion in battery!
What does the numbers on a Li-Po battery mean?
Li-Po batteries are labeled with "mAh", "S ratings" and "C ratings".

mAh stands for milliampere-hour; This represents the capacity of the battery.

'S rating' shows the number of cells that your battery has. If your battery has 3 cells then you get a voltage of 3 X 3.7 V across the terminals of a battery (under perfect circumstances).

'C rating' of the battery explains how many amps of current can be drawn continuously from the battery without damaging it.

Servo

Moving onto servos, Servos moves the control surfaces on a RC airplane to control altitude or direction of the airplane. For this airplane, we obviously require 2 servos. One to control the altitude and another to control direction. I'm using 2 X 9g digital nylon geared servos.

Transmitter and Receiver

Finally, we need a Transmitter and Receiver for controlling the airplane.
Channels on the Transmitter and receiver:
Channels on the Transmitter and receiver decide how many functions or controls you get. For this airplane, we need 3 channels. That is Throttle, Rudder and Elevator. Where throttle controls the speed of the airplane, Rudder controls the direction and Elevator controls the altitude.

I'm using a FlySky FS-T6 2.4ghz transmitter with FlySky R6-B receiver.

# data[].attributes.attachment_link.description
Once you have decided how big your airplane is going to be, start by choosing a proportional propeller. By proportional I mean you don't want to choose too big or small prop for your airplane. Now, determining the size of propeller sure requires some maths.

# data[].attributes.body
http://www.instructables.com/id/Arduino-Turn-ON-Your-LEDs-and-Lamps-With-a-Clap-Re/

It's a very practical project which can be used in everyday situations.

# data[].attributes.body
Voice Controlled Arduino Drone

I want to see how well this can work when the price is meant to be only 11 pounds
http://www.instructables.com/id/SpeechVoice-Controlled-Arduino-Drone/

# data[].attributes.headline
Artificial Intelligence Neural Network on an Aurduino Aidan Ewart

# data[].attributes.subject
Artificial Intelligence Neural Network on an Aurduino Aidan Ewart

# data[].attributes.body
Teach it to recognise an image or sound sequence or something.
http://www.instructables.com/id/Making-Microcontroller-Artificially-Intelligent-Ne/