Kuman K1Arduino KIT Tutorials

Http://www.kumantech.
com kuman
Kuman K1 Super Starter Kit

Tutorial for Arduino Uno R3
Kuman is a professional manufacturer and exporter that is involved in the design, development, production and
marketing of arduino accessories, 3D printers, Raspberry Pi accessories. We are located in shenzhen which is
known as the chinese silicon valley. All of our products comply with international quality standards and are greatly
appreciated in a variety of different markets throughout the world.
Official website:http://www.kumantech.com
We're just happy that you're happy.
Happy
If you don't know how to express your newfound joy, we've got a few suggestions.
Tell your friends, hobbyists and family
Share your experience by writing a review on our online store
Connect with us on kumantech.com, facebook: kumantech, twitter: kumantech Instagram: kumantech
Not happy?
Our friendly customer care team will work hard to put a smile back on your face.
Here's how we can connect:
Phone: +86 755 23021270 Mon-Sat 9:00-18:30
Email: [email protected]
We have a professional team in USA , Canada, UK, Germany, France, Italy ,Spain and Japan to work with our
Kuman China factory to give you 100% satisfied service.
Our Tutorial
This tutorial is geared for beginners. You will learn all the basic information about how to use arduino controller
board, sensors and components. If you want to study arduino in more depth,we recommend that you read the
arduino cookbook written by michael margolis.
Our after-sales
If you have any question,comment or suggestion about our company,product or tutorial,please don’t hesitate to
send an email: [email protected] are committed to continuous improvement so your feedback is
invaluable.
1
Http://www.kumantech.com kuman
2
3
4
5
Lesson Listing
Lesson0 lnstalling IDE
Lesson1 Add Libraries
Lesson2 Blink
Lesson3 LED
Lesson4 button
Lesson5 Fire alarm test
Lesson6 8x8 dot matrix experiment
Lesson7 Active Buzzer module
Lesson8 Passive buzzer
Lesson9 1602 liquid crystal experiment
Lesson 10 74HC595 experiment
Lesson 11 digital tube display experiment
Lesson12 Four bit digital tube
Lesson13 Hit module
Lesson14 Tilt-Switch
Lesson15 ultrasonic distance measuring module
Lesson16 thermal resistance
Lesson17 step motor test
Lesson18 steering gear control experiment
Lesson19 photosensitive lamp experiment
Lesson20 LM35 Temperature Sensor
Lesson21 LED Scintillation test
Lesson22 Infrared-Receiver
Lesson23 Potentiometer
Lesson 24 Analog temperature sensor
Lesson 25 Touch module
Lesson 26 3 color - full color LED Module
6
Lesson0 lnstalling IDE

Introduction:
If we want to learn and use the Arduino, necessary to manually install the driver first, fortunately the Arduino IDE
package shipped.
Here we introduce the method of installation:
1：We can have the Arduino website (www.Arduino.cc) to download，
Click on the "Download"
Click the arrow pointing,
Download it here.
7
After the download is a compressed package, and then extract
2：Connect the motherboard and the computer, check the "device manager".
Right click on the "unknown device" and then click "new driver"
8
Click next, driver installation is complete.
Then look at "device manager".
9
Here you can see "Arduino Uno (com3)", it is proved that drive successful installation.
Boards and Ports：

You are now ready to start the Arduino Software, so whatever platform you are using, open the Arduino folder
and open the Arduino application contained within it.
This will start the Arduino IDE, but before you can start programming, you have to tell the Arduino software which
10
type of Arduino board you are using and also select the port to which it is connecting.
To tell the Arduino IDE which type of board you are using. from the 'Tools' menu, select Board and then 'Arduino
Uno' or 'Leonardo' as appropriate.
Also on the 'Tools' menu, you will find the 'Serial Port' option. Select this option.
If you are using Windows, there will probably only be one option here and it will either say COM3 or COM4. Even
though there is only one option, you will still need to select it.
11
Lesson1 Add Libraries

Once you are comfortable with the Arduino software and using the built-in functions, you may want to extend its
functionality with additional libraries.
What are Libraries?
Libraries are a collection of code that makes it easy for you to connect to a sensor, display, module, etc. For
example, the built-in LiquidCrystal library makes it easy to talk to character LCD displays. There are hundreds of
additional libraries available on the Internet for download. The built-in libraries and some of these additional
libraries are listed in the reference. To use these additional libraries, you will need to install them.
How to Install a Library
Using the Library Manager
To install a new library into your Arduino IDE, you can use the Library Manager (available from IDE version 1.6.2).
12
Open the IDE and click Sketch > Include > Library > Manage Libraries.
The library manager will open and you will find a list of libraries that are already installed or
ready for installation. In this example, we will install the Bridge library. Scroll down the list to find it, then select
the version of the library you want to install. Sometimes, only one version of the library is available. If the version
selection menu does not appear, don't worry; it is normal.
Finally click on install and wait for the IDE to install the new library. Downloading may take time depending on
your connection speed. Once it has finished, an Installed tag should appear next to the Bridge library. You can
close the library manager.
13
You can now find the new library available in the Include Library menu. If you want to add your own library open a
new issue on github.
Importing a .zip Library
Libraries are often distributed as a ZIP file or folder. The name of the folder is the name of the library. Inside the
folder will be the following: .cpp file, .h file, often a keywords.txt file, examples folder, and other files required by
the library. Starting with version 1.0.5, you can install third-party libraries in the IDE. Do not unzip the downloaded
library; leave it as-is.
In the Arduino IDE, navigate to Sketch > Include Library > Add .ZIP Library.
You will be prompted to select the library you would like to add. Navigate to the .zip file's location and open it.
Return to the Sketch > Import Library menu. You should now see the library at the bottom of the drop-down
menu. It is ready to be used in your sketch. The zip file will have been expanded in the libraries folder in your
Arduino sketches directory.
NB: The Library will be available to use in sketches, but examples for the library will not be shown in the File >
Examples until after the IDE has restarted.
Manual installation
To install the library, first, quit the Arduino application. Then unzip the ZIP file containing the library. For example,
if you're installing a library called "ArduinoParty", uncompress ArduinoParty.zip. It should contain a folder called
ArduinoParty, with files like ArduinoParty.cpp and ArduinoParty.h inside. (If the .cpp and .h files aren't in a folder,
you'll need to create one. In this case, you'd make a folder called "ArduinoParty" and move into it all the files that
were in the ZIP file, like ArduinoParty.cpp and ArduinoParty.h.)
14
Drag the ArduinoParty folder into this folder (your libraries folder). Under Windows, it will likely
be called "My Documents\Arduino\libraries". For Mac users, it will likely be called "Documents/Arduino/libraries".
On Linux, it will be the "libraries" folder in your sketchbook. Your Arduino library folder should now look like this
(on Windows):
My Documents\Arduino\libraries\ArduinoParty\ArduinoParty.cpp
My Documents\Arduino\libraries\ArduinoParty\ArduinoParty.h
My Documents\Arduino\libraries\ArduinoParty\examples
or like this (on Mac and Linux):

Documents/Arduino/libraries/ArduinoParty/ArduinoPrty.cpp
Documents/Arduino/libraries/ArduinoParty/ArduinoParty.h
Documents/Arduino/libraries/ArduinoParty/examples
There may be more files than just the .cpp and .h files so make sure they're all there. (The library won't work if
you put the .cpp and .h files directly into the libraries folder or if they're nested in an extra folder. For example:
Documents\Arduino\libraries\ArduinoParty.cpp and Documents\Arduino\libraries\ArduinoParty\ArduinoParty\
ArduinoParty.cpp won't work.)
Restart the Arduino application. Make sure the new library appears in the Sketch > Import Library menu. That's it.
You've installed a library!
Summary
In this lesson, we will install all the libraries that we will use in the tutorial. Open the libraries folder and install the
ZIP files one by one so we won't need to do this step in the following lessons. We just connect the component as
the schematic and upload the code provided. Then the kit will work.
Lesson2 Blink
Overview
In this lesson, you will learn how program your UNO R3 controller board to make the Arduino's built-in LED blink.
Component Required
(1) x Arduino Uno R3
Principle
15
The UNO R3 board has rows of connectors along both sides that are used to connect to several electronic devices
and plug-in 'shields' that extends its capability.
It also has a single LED that you can control from your sketches. This LED is built onto the UNO R3 board and is
often referred to as the 'L' LED as this is how it is labeled on the board.
You may find that your UNO R3 board 's 'L' LED already blinks when you connect it to a USB plug. This is because
the boards are generally shipped with the 'Blink' sketch pre-installed
In this lesson, we will reprogram the UNO R3 board with our own Blink sketch and then change the rate at which
it blinks.
In Lesson 0, you set up your Arduino IDE and made sure that you could find the right serial port for it to connect
to your UNO R3 board. The time has now come to put that connection to the test and program your UNO R3
board.
The Arduino IDE includes a large collection of example sketches that you can load up and use. This includes an
example sketch for making the 'L' LED blink.
Load the 'Blink' sketch that you will find in the IDE's menu system under File > Examples > 01.Basics
16
When the sketch window opens, enlarge it so that you can see the entire sketch in the window
The example sketches included with the Arduino IDE are 'read-only'. That is, you can upload them to an UNO R3
board, but if you change them, you cannot save them as the same file.
Since we are going to change this sketch, the first thing you need to do is save your own copy.
From the File menu on the Arduino IDE, select 'Save As..' and then save the sketch with the name 'MyBlink'
17
You have saved your copy of 'Blink' in your sketchbook. This means that if you ever want to
find it again, you can just open it using the File > Sketchbook menu option.
Attach your Arduino board to your computer with the USB cable and check that the 'Board Type' and 'Serial Port'
are set correctly. You may need to refer back to Lesson 0.
The Arduino IDE will show you the current settings for board at the bottom of the window.
Click on the 'Upload' button. The second button from the left on the toolbar.
If you watch the status area of the IDE, you will see a progress bar and a series of messages. At first, it will say
'Compiling Sketch...'. This converts the sketch into a format suitable for uploading to the board.
18
Next, the status will change to 'Uploading'. At this point, the LEDs on the Arduino should start to flicker as the
sketch is transferred.
Finally, the staus will change to 'Done'.
The other message tells us that the sketch is using 1,084 bytes of the 32,256 bytes available.After the 'Compiling
Sketch..' stage you could get the following error message.
It can mean that your board is not connected at all, or the drivers have not been installed (if necessary) or that the
wrong serial port is selected.
If you encounter this, go back to Lesson 0 and check your installation.
Once the upload has completed, the board should restart and start blinking. Open the code
Note that a huge part of this sketch is composed of comments. These are not actual program instructions; rather,
they just explain how the program works. They are there for your benefit.
19
Everything between /* and */ at the top of the sketch is a block comment; it explains what the sketch is for.
Single line comments start with // and everything up until the end of that line is considered a comment.
The first line of code is:
int led = 13;
As the comment above it explains, this is giving a name to the pin that the LED is attached to. This is 13 on most
Arduinos, including the UNO and Leonardo.
Next, we have the 'setup' function. Again, as the comment says, this is executed when the reset button is pressed.
It is also executed whenever the board resets for any reason, such as power first being applied to it, or after a
sketch has been uploaded.
void setup() {
// initialize the digital pin as an output. pinMode(led, OUTPUT);
}
Every Arduino sketch must have a 'setup' function, and the place where you might want to add instructions of
your own is between the { and the }.
In this case, there is just one command there, which, as the comment states tells the Arduino board that we are
going to use the LED pin as an output.
It is also mandatory for a sketch to have a 'loop' function. Unlike the 'setup' function that only runs once, after a
reset, the 'loop' function will, after it has finished running its commands,
immediately start again.

void loop()
{
digitalWrite(led, HIGH);
delay(1000);
digitalWrite(led, LOW);
delay(1000);
}
Inside the loop function, the commands first of all turn the LED pin on (HIGH) then 'delay' for 1000 milliseconds (1
second), then turn the LED pin off and pause for another second.
You are now going to make your LED blink faster. As you might have guessed, the key to this lies in changing the
parameter in () for the 'delay' command.
20
This delay period is in milliseconds, so if you want the LED to blink twice as fast, change the value from 1000 to
500. This would then pause for half a second each delay rather than a whole second.
Upload the sketch again and you should see the LED start to blink more quickly
Lesson 3 LED
Overview
In this lesson, you will learn how to change the brightness of an LED by using different values of resistor.
Component Required:
(1) x Ardino Uno R3
(1) x 5mm red LED
(1) x 220 ohm resistor
(1) x 1k ohm resistor
(1) x 10k ohm resistor
(2) x M-M wires
Component Introduction
BREADBOARD MB-102
A breadboard enables you to prototype circuits quickly, without having to solder the connections. Below is an
example.
21
Breadboards come in various sizes and configurations. The simplest kind is just a grid of holes in a plastic block.
Inside are strips of metal that provide electrical connection between holes in the shorter rows. Pushing the legs of
two different components into the same row joins
them together electrically. A deep channel running down the middle indicates that there is a break in connections
there, meaning, you can push a chip in with the legs at either side of the channel without connecting them
together. Some breadboards have two strips of holes running along the long edges of the board that are
separated from the main grid. These have strips running down the length of the board inside and provide a way to
connect a common voltage. They are usually in pairs for +5 volts and ground. These strips are referred to as rails
and they enable you to connect power to many components or points in the board.
While breadboards are great for prototyping, they have some limitations. Because the connections are push-fit
and temporary, they are not as reliable as soldered connections. If you are having intermittent problems with a
circuit, it could be due to a poor connection on a breadboard.
LED:
LEDs make great indicator lights. They use very little electricity and they pretty much last forever.
In this lesson, you will use perhaps the most common of all LEDs: a 5mm red LED. 5mm refers to the diameter of
the LED. Other common sizes are 3mm and 10mm.
You cannot directly connect an LED to a battery or voltage source because 1) the LED has a positive and a negative
lead and will not light if placed the wrong way and 2) an LED must be used with a resistor to limit or 'choke' the
amount of current flowing through it; otherwise, it will burn out!
22
I If you do not use a resistor with an LED, then it may well be destroyed almost immediately, as too much current
will flow through, heating it and destroying the 'junction' where the light is produced.
There are two ways to tell which is the positive lead of the LED and which the negative.
Firstly, the positive lead is longer.
Secondly, where the negative lead enters the body of the LED, there is a flat edge to the case of the LED.
If you happen to have an LED that has a flat side next to the longer lead, you should assume that the longer lead is
positive.
RESISTORS:
As the name suggests, resistors resist the flow of electricity. The higher the value of the resistor, the more it resists
and the less electrical current will flow through it. We are going to use this to control how much electricity flows
through the LED and therefore, how brightly it shines.
But first, more about resistors...
The unit of resistance is called the Ohm, which is usually shortened to Ω the Greek letter
Omega. Because an Ohm is a low value of resistance (it doesn't resist much at all), we also denote the values of
resistors in kΩ (1,000 Ω) and MΩ (1,000,000 Ω). These are called kilo-ohms and mega-ohms.
In this lesson, we are going to use three different values of resistor: 220Ω, 1kΩ and 10kΩ.
These resistors all look the same, except that they have different colored stripes on them. These stripes tell you
the value of the resistor.
The resistor color code has three colored stripes and then a gold stripe at one end.
23
Unlike LEDs, resistors do not have a positive and negative lead. They can be connected either way around.
Connection
Schematic
24
wiring diagram
The UNO is a convenient source of 5 volts, which we will use to provide power to the LED and
the resistor. You do not need to do anything with your UNO, except to plug it into a USB cable.
With the 220 Ω resistor in place, the LED should be quite bright. If you swap out the 220 Ω resistor for the 1kΩ
25
resistor, then the LED will appear a little dimmer. Finally, with the 10 kΩ resistor in place, the LED will be just
about visible. Pull the red jumper lead out of the breadboard and touch it into the hole and remove it, so that it
acts like a switch. You should just be able to notice the difference.
At the moment, you have 5V going to one leg of the resistor, the other leg of the resistor going to the positive side
of the LED and the other side of the LED going to GND. However, if we moved the resistor so that it came after the
LED, as shown below, the LED will still light.
You will probably want to put the 220Ω resistor back in place.
It does not matter which side of the LED we put the resistor, as long as it is there somewhere.6
Lesson 4 button
26
Introduction
In this experiment, you will learn how to turn on/off an LED by using an I/O port and a button. The
"I/O port" refers to the INPUT and OUTPUT port. Here the INPUT port of the SunFounder Uno
board is used to read the output of an external device. Since the board itself has an LED (connected
to Pin 13), so you can use this LED to do this experiment for convenience.
Components
- 1 * kuman Uno board
- 1 * USB cable
- 1 * Button
- 1 * Resistor (10k Ohm)
- Jumper wires
- 1 * Breadboard
Principle
Button
Buttons are a common component used to control electronic devices. They are usually used as
switches to connect or disconnect circuits. Although buttons come in a variety of sizes and shapes,
the one used here is a 6mm mini-button as shown in the following pictures. Pins pointed out by the
arrows of same color are meant to be connected.
27
When the button is pressed, the pins pointed by the blue arrows will connect to the pins pointed by
the red arrows.
Generally, the button is directly connected in an LED circuit in order to turn on or off the LED. This
connection is relatively simple. However, sometimes the LED will light up automatically without
pressing the button, which is caused by various interferences. In order to avoid these external
interferences, a pull-down resistor is used, that is, to connect a 1K–10KΩ resistor between the
button port and GND. It is used to consume external interferences while connected to GND for as
long as the button switch is turned off.
This circuit connection is widely used in numerous circuits and electronic devices. For example, if
you press any button on your mobile phone, the backlight will light up.
Experimental Procedures
Step 1: Build the circuit
28
The schematic diagram：
29
Step2: Compile the code
Step 3: Upload the sketch to the KUMAN Uno board
Now, press the button, and the LED on the KUMAN Uno board will light up.
Code:
//Controlling Led By Button

//Turns on and off a LED ,when pressings button attach to pin12
//2015.5.7
/**********************************/
const int keyPin = 12; //the number of the key pin
const int ledPin = 13;//the number of the led pin
/**********************************/
30
void setup()
{
pinMode(keyPin,INPUT);//initialize the key pin as input
pinMode(ledPin,OUTPUT);//initialize the led pin as output
}
/**********************************/
void loop()
{
//read the state of the key value
//and check if the kye is pressed
//if it is,the state is HIGH
if(digitalRead(keyPin) ==HIGH )
{
digitalWrite(ledPin,HIGH);//turn on the led
}
else
{
digitalWrite(ledPin,LOW);//turn off the led
}
}
/************************************/
31
Lesson 5 Fire alarm test
Long feet Flame sensor connection A5, short feet connect 5 v, A5 a 10 k resistor to the GND Pin connections, the
positive connection of the buzzer D8, negative connection GND, then download the code, can use the fire source
close to the sensor, to test the experiment
32
Components:
- 1 * USB cable
- 1 * Mini bread plate
- Jumper wires
- 1 * UNO extension plate

- 1 * buzzer
-1 * Flame sensor
-1 * resistance 10 k
Code：
int flame=A5;//Define flame interface

int Beep=8;//Define buzzer interface
int val=0;//Define numeric variables
val void setup()

{ pinMode(Beep,OUTPUT);//Define Beep as output interface
pinMode(flame,INPUT);//Define flame as input interface
Serial.begin(9600);//Set the baud rate is 9600
}
void loop()
{
33
val=analogRead(flame);//Simulated values of the flame sensor
Serial.println(val);//Output analog value, and print it out
if(val>=600)//When the analog value is greater than 600 when the buzzer sounds
{ digitalWrite(Beep,HIGH);
}
else { digitalWrite(Beep,LOW);
}
}
34
Lesson6 8x8 dot matrix experiment
1.8*8 dot matrix diagram
2.8*8 dot matrix physical map
35
Figure 8 x 8 dot matrix LED appearance and pin diagram, its equivalent circuit as shown in figure (2), as long as its
corresponding Y, X axis forward bias, you can make LED shine. For example, if you want to make the upper left
corner LED lit, then X0=0, Y0=1 can be placed on the X axis or Y axis
3. 8*8 dot matrix scanning mode

LED generally use the scan type display, the actual use of three ways（1）spot scan
（2）Column scan
16 * 64=1024Hz period less than 1ms. If you use the second and the third way, frequency must be greater than 16
* 8=128Hz period less than 7.8ms conforming to the requirements of the persistence of vision. In addition a drive
a column or row (eight LEDs) to an external driving circuit improves the current, otherwise LED light degree would
be enough.
4. Examples of 8*8 dot matrix applications
Pin pin pin point when internal lattice structure and shape are as follows, 8x8 dot matrix consists of
64 light emitting diode, and each light emitting diode is placed in rows in line and column
intersection, corresponding to a set level, a column set to zero level, the corresponding diode is
bright; as to the first light, 9 high level 13 low level, the first point is bright; if the first line is light,
the 9 feet meets high level, and 13,3,4,10,6,11,15,16 these pins low level. So the first line will be
light to the first light column, 13 of the low level, and 9,14,8,12,1,7,2,5) to the high level, then the
first column will be lit.
Generally we use the dot matrix display Chinese characters is a 16 * 16 dot matrix font font, the
so-called 16 * 16, is each Chinese character in the longitudinal, cross each of the 16 points in the
region show. That is to say with four 8 * 8 dot matrix into a 16 * 16 dot matrix. As shown in the
following illustration, "you" is corresponding to light, because our lattice in the column is low level
effectively, and the row line is active high, so to show "you" word, it bit code information to take
anti, namely all columns (13 to 16 feet) send (1111011101111111,0xF7,0x7F ), and the first line (9
feet) to send a signal, then first send. Sending the second line to display data (13 to 16 feet) to send
1111011101111111,0xF7,0x7F, and the second line (14 feet) to send signal 1. By analogy, as long as
each row of data shows that the time interval is short enough, to suspend the effects of the use of
human vision, so send 16 times scanning data after 16, you will see a "you" word; the second kind
of method of data sent is matrix signal sent to the line of the re scan the column is the same
36
reason. Similarly to the word "you" to illustrate, 16 (9,14,8,12 , 1,7,2,5) send
(0000000000000000,0x00,0x00) and the first column (13 feet) to send, "0". Similarly scanning the
second column. When the line of sent 16 data column scanning the 16 times a "you" word is
displayed the.
● ● ●
● ●
● ●
● ●
● ●
● ●
● ● ●
Therefore, formation of the column code to 00h, 00h, 3EH, 41h, 41h, 3EH, 00h, 00h; as long as the these codes
are respectively sent to the corresponding column above, you can achieve "0" digital display.
Connection diagram of this experiment.
Components
- 1 * KUMAN Uno board
- 1 * Breadboard
- Jumper wires
37
- 8x8 dot matrix
- 8 * Resistor (220R)
- 1 * USB cable
Lit 8X8 dot matrix LED a LED as follows：
*******************************************************************************
Instance code:
//the pin to control ROW
const int row1 = 2; // the number of the row pin 9
//the pin to control COl
const int col1 = 6; // the number of the col pin 13
38
void setup(){
int i = 0 ;
for(i=2;i<18;i++)
{
pinMode(i, OUTPUT);
}
pinMode(row5, OUTPUT);
for(i=2;i<18;i++) {
digitalWrite(i, LOW);
}
digitalWrite(row5, LOW);
}
void loop(){
int i;
//the row # 1 and col # 1 of the LEDs turn on
digitalWrite(row1, HIGH);
digitalWrite(col1, LOW);
digitalWrite(col2, HIGH);
delay(1000);
//turn off all
for(i=2;i<18;i++) {
}
delay(1000);
}
39
***********************************************************************
The other experimental code is as follows:
Display A this letter, then the position in the dot matrix 1 through dynamic scanning display
code：
#define display_array_size 8
// ascii 8x8 dot font
#define data_null 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 // null char
#define data_ascii_A 0x02,0x0C,0x18,0x68,0x68,0x18,0x0C,0x02 /*"A",0*/
/**
**"A"
#define A { //
{0, 0, 0, 0, 0, 0, 1, 0}, //0x02
{0, 0, 0, 0, 1, 1, 0, 0}, //0x0C
{0, 0, 0, 1, 1, 0, 0, 0}, //0x18
{0, 1, 1, 0, 1, 0, 0, 0}, //0x68
{0, 1, 1, 0, 1, 0, 0, 0}, //0x68
{0, 0, 0, 1, 1, 0, 0, 0}, //0x18
{0, 0, 0, 0, 1, 1, 0, 0}, //0x0C
{0, 0, 0, 0, 0, 0, 1, 0} //0x02
}
**/
#define data_ascii_B 0x00,0x7E,0x52,0x52,0x52,0x52,0x2C,0x00 /*"B",1*/
#define data_ascii_C 0x00,0x3C,0x66,0x42,0x42,0x42,0x2C,0x00 /*"C",2*/
#define data_ascii_D 0x00,0x7E,0x42,0x42,0x42,0x66,0x3C,0x00 /*"D",3*/
#define data_ascii_E 0x00,0x7E,0x52,0x52,0x52,0x52,0x52,0x42 /*"E",4*/
#define data_ascii_F 0x00,0x7E,0x50,0x50,0x50,0x50,0x50,0x40 /*"F",5*/
40
#define data_ascii_G 0x00,0x3C,0x66,0x42,0x42,0x52,0x16,0x1E /*"G",6*/
#define data_ascii_H 0x00,0x7E,0x10,0x10,0x10,0x10,0x7E,0x00 /*"H",7*/
#define data_ascii_I 0x00,0x00,0x00,0x7E,0x00,0x00,0x00,0x00 /*"I",8*/
// display array
byte data_ascii[][display_array_size] = {
data_null,
data_ascii_A, data_ascii_B,
data_ascii_C,
data_ascii_D,
data_ascii_E,
data_ascii_F,
data_ascii_G,
data_ascii_H,
data_ascii_I,
};
//the pin to control ROW
//the pin to control COl
void displayNum(byte rowNum,int colNum)

{
int j;
byte temp = rowNum;
for(j=2;j<6;j++)
{
digitalWrite(j, LOW);
}
41
for(j=6;j<14;j++)
{
digitalWrite(j, HIGH); }
switch(colNum)
{
case 1: digitalWrite(col1, LOW); break;
default: break;
}
for(j = 1 ;j < 9; j++)
{
temp = (0x80)&(temp) ;
if(temp==0)
{
temp = rowNum<<j;
continue;
}
switch(j)
{
case 1: digitalWrite(row1, HIGH); break;
default: break;
}
temp = rowNum<<j;
}
}
void setup(){
int i = 0 ;
for(i=2;i<18;i++)
42
{
pinMode(i, OUTPUT);
}
for(i=2;i<18;i++) {
}
}
void loop(){
int t1;
int l;
int arrage;
for(arrage=0;arrage<10;arrage++)
{
for(l=0;l<512;l++)
{
for(t1=0;t1<8;t1++)
{
displayNum(data_ascii[arrage][t1],(t1+1));
}
}
}
}
Lesson7 Active Buzzer module
Arduino buzzer module

Active speaker
Compatible with PC, printer, car audio system DIY
Specifications:
43
Voltage: 5V
Color: Black + silver gray
Package dimension: 77x42x13mm
Weight: 5g
Test Requires
Arduino Controller × 1
USB Cable × 1
Buzzer Module × 1
10K potentiometer（10K） × 1
Connection:
44
Below test is use Analog to control buzzer frequency.

Pin10 is to control buzzer.
Pin3 is Analog control, and we use 10K potentiometer.
Function: Adjust potentiometer, we can hear buzzer frequency change.
int speakerPin = 8;//Control horn pin
int potPin = 4;//Pin for controlling the adjustable resistor
int value = 0;
void setup() {
pinMode(speakerPin, OUTPUT);
}
void loop() {
value = analogRead(potPin);Read the value of the resistor pin

digitalWrite(speakerPin, HIGH);
delay(value);Adjust the time of the horn;
digitalWrite(speakerPin, LOW);
delay(value);Adjust the duration of the horn;
}
We can use potentiometer to change delay time, then we can change buzzer frequency.
45
Here we add a button switch to control the buzzer, so we can simulate a simple doorbell, when the
When the button is pressed the speaker can make a sound.

Another Test:
We add button to control buzzer, then we can imitate a simple doorbell. When push button, buzzer can ring.
Connect way:
Code:
const int buttonPin = 4; // Push pin;

const int speakerPin = 8; //Buzzer pin;
// variables will change:
int buttonState = 0; // Read a value of the button pin
void setup()
{
//Set the button pin for the input mode, the buzzer pin for the output mode;
pinMode(buttonPin, INPUT);
}
void loop(){
// Read the key to an initial value, here in the circuit, I was in the default high, so the initial value is high;
buttonState = digitalRead(buttonPin);
/*If the button is high, then the buzzer does not ring;
46
Because I just started in the hardware circuit in the initial value is high, so the if condition was established, the
buzzer does not ring
*/
if (buttonState == HIGH) {
digitalWrite(speakerPin,LOW);
}
else {
//The value of the button here is low (also when the button is pressed).
digitalWrite(speakerPin,HIGH);
}
}
Below is use PWM to control buzzer:

Code:
int speakerPin = 8;
byte song_table[] = { 30, 30, 30, 40, 50, 60, 70, 80, 90, 100,110, 120, 130, 140,
150, 160, 170, 180, 190, 200, 210, 220, 230, 240, 250, 250, 240, 230, 220, 210, 200, 190, 180,
170, 160, 150, 140, 130, 120, 110, 100, 90, 80, 70, 60, 50, 40, 30, 30, 30 };
int MAX = 50;
int count = 0;
void setup() {
}
void loop() {
analogWrite(speakerPin,song_table[count]);
count ++;
if (count > MAX) {
count = 0;
}
delay(50);
}
Lesson8 Passive buzzer
47
Introduction
A buzzer is a great tool in your experiments whenever you want to make some sounds.
Components
- 1 * Breadboard
- 1 * USB data cable
- 1 * Buzzer (Active)
- Jumper wires
Experimental Principle
As a type of electronic buzzer with an integrated structure, buzzers, which are supplied by DC power, are widely
used in computers, printers, photocopiers, alarms, electronic toys, automotive electronic devices, telephones,
timers and other electronic products for voice devices. Buzzers can be categorized as active and passive ones (see
the following picture). Turn the pins of two buzzers face up, and the one with a green circuit board is a passive
buzzer, while the other enclosed with a black tape is an active one
The difference between an active buzzer and a passive buzzer:
An active buzzer has a built-in oscillating source, so it will make sounds when electrified. But a
passive buzzer does not have such source, so it will not tweet if DC signals are used; instead, you
need to use square waves whose frequency is between 2K and 5K to drive it. The active buzzer is
often more expensive than the passive one because of multiple built-in oscillating circuits.
In this experiment, we use an active buzzer.
48

The schematic diagram:
49
Step 2: Compile the code
Code
// Buzzer
// buzzer make sounds
//Email:[email protected]
/***********************************/
int buzzer = 12;//the pin of the active buzzer
void setup()
{
pinMode(buzzer,OUTPUT);//initialize the buzzer pin as an output
}
void loop()
{
unsigned char i; //define a variable
while(1)
{
//output an frequency
for(i=0;i<80;i++)
{
digitalWrite(buzzer,HIGH);
delay(1);//wait for 1ms
digitalWrite(buzzer,LOW);
}
//output another frequency
for(i=0;i<100;i++)
{
digitalWrite(buzzer,HIGH);
digitalWrite(buzzer,LOW);
}
}
}
/****************************************/
Arduino to complete the interactive works there are many, the most common also is the most commonly used is
sound and light show, the front has been with LED lights in doing the experiment, the experiment let everyone's
50
circuit sound, voice of the most common components is a buzzer and a speaker, the comparison of the two buzzer
is more simple and easier to use so we this experiment with buzzer.
Buzzer and its principle
（一）Introduction of buzzer
1 ． The action of buzzer buzzer is an integrated structure of the electronic buzzer, DC
voltage power supply, widely used in computer, printers, photocopiers, alarm, electronic
toys, automotive electronics, telephone, timers, etc. electronic products for sound devices.
2 ． Buzzer buzzer classification is divided into two types of piezoelectric buzzer and
electromagnetic buzzer。
3．Buzzer circuit graphics symbol buzzer in the circuit with the letter "H" or "HA" (the old
standard with "FM", "LB", "JD", etc.)。
（二）Structure principle of buzzer
1The piezoelectric buzzer buzzer is mainly composed of a multi harmonic oscillator, a
piezoelectric buzzing piece, an impedance matching device and a resonance box, a shell
and the like.
The multi harmonic oscillator is composed of a transistor or an integrated circuit, when the
power supply is switched on, the 1.5~15V DC operating voltage is switched on, the multi
harmonic oscillator is played and the audio signal of the 1.5~2.5kHZ is output, and the
impedance matching device drives the piezoelectric buzzer to sound.。
The piezoelectric buzzing piece is made of lead zirconium titanate or lead magnesium
acid lead piezoelectric ceramic material, which is plated with silver electrode on both sides
of the ceramic sheet, and then is adhered to the brass sheet or stainless steel sheet after
polarization and aging treatment.。
2 ． The electromagnetic buzzer is composed of an oscillator, an electromagnetic coil, a
magnet, a vibrating diaphragm and an outer shell, etc. the audio signal of the oscillator is
connected with an electromagnetic coil, and the electromagnetic coil generates a magnetic
field.
What is the difference between active and passive buzzer
Here the "source" is not a power source, but refers to the source of the shock. That is, the
source of the active buzzer inside with a source, so as long as a power will be called.
The source is not a source of internal power, so if you use a DC signal can not make it a
tweet. You must use the 2K~5K square wave to drive it.
Active buzzer is often more expensive than passive, just because there are multiple shock
circuit
The advantages of passive buzzer is: 1. Cheap, 2. The voice frequency controllable can make
"to send a cable Raschig" effect. In some special cases, and led a MUX control active buzzer
of the advantages of program control convenient.
ARDUINO reference source program:

int buzzer=8;//Set the number of IO pins to control the buzzer
void setup()
{
51
pinMode(buzzer,OUTPUT);//Set the digital IO foot mode, OUTPUT for the output
}
void loop()
{
unsigned char i,j;// defined variable
while(1)
{
for(i=0;i<80;i++)//Output a frequency of sound
{
digitalWrite(buzzer,HIGH);//Hair sound
delay(1);//delay 1ms
digitalWrite(buzzer,LOW);//No sound
}
for(i=0;i<100;i++)//Output another frequency of sound
{
digitalWrite(buzzer,HIGH);//Hair sound
digitalWrite(buzzer,LOW);//No sound
}
}
}
Download the program, the buzzer experiment is completed.
Lesson9 1602 liquid crystal experiment

This test uses the Arduino direct drive 1602 liquid crystal display text
1602 liquid crystal in the application is very wide, the initial 1602 liquid crystal is used HD44780 controller, and
now the 1602 modules of the various manufacturers are basically using a compatible with IC, so the
characteristics are basically the same.
Main technical parameters of 1602LCD
Display capacity is 16 x 2 characters;
Chip operating voltage is 4.5 ~ 5.5V;
Operating current is 2.0mA (5.0V);
The best operating voltage of the module is 5.0V;
Character size 2.95 x 4.35 (W * H) mm.
1602 LCD interface pin definition
52
interface specification:
1, a group of two groups of power supply is a module of the power supply is a group of backlight power supply is
generally used 5V power supply. This test backlight using 3.3V power supply can work.
2 、 VL is a regulator of the contrast of the pin, series is not greater than 5K potentiometer to adjust. This
experiment uses 1K ohm resistor to set the contrast. Its connection points high potential and low potential
connection, the use of low potential connection, series 1K ohm resistance after GND.
3、RS is a lot of liquid crystal on the pin is the command / data selection pin the pin level is high when the data
indicated that the data will be carried out.。
4 、 RW is also a lot of liquid crystal on the pin is the choice of reading and writing the pin level is high is the
representation of the liquid crystal to read operation for the low time that the write operation.
5、E also a lot of liquid crystal module this pin is usually on the bus signal stability after the signal to a positive
pulse notice to read the data in this pin for the high level when the bus is not allowed to change.
6、D7 - D0 8 two-way parallel bus, used to transmit commands and data.
7、BLA is the back light source cathode, BLK is the back light source cathode.
1602 the basic operation of the liquid crystal is divided into the following four kinds:
53
The figure is 1602 LCD physical map
1602 direct communication with Arduino, according to the product manual description, divided into 8 connection
method and 4 connection method, we first use the 8 connection method for the experiment.
54
Code as follows
55
int DI = 12;
int RW = 11;
int DB[] = {3, 4, 5, 6, 7, 8, 9, 10};//Use an array to define the pins needed by the bus
int Enable = 2;
void LcdCommandWrite(int value) {

// Define all pins
int i = 0;
for (i=DB[0]; i <= DI; i++) //Bus assignment
{
digitalWrite(i,value & 01);//Because the 1602 liquid crystal signal recognition is D7-D0 (not D0-D7), here is used
to reverse the signal.
value >>= 1;
}
digitalWrite(Enable,LOW);
delayMicroseconds(1);
digitalWrite(Enable,HIGH);
delayMicroseconds(1); //delay 1ms
delayMicroseconds(1); // delay 1ms
}
void LcdDataWrite(int value) {

// Define all pins
int i = 0;
digitalWrite(DI, HIGH);
digitalWrite(RW, LOW);
for (i=DB[0]; i <= DB[7]; i++) {
digitalWrite(i,value & 01);
value >>= 1;
}
delayMicroseconds(1); //Delay 1ms
}
void setup (void) {

int i = 0;
for (i=Enable; i <= DI; i++) {
pinMode(i,OUTPUT);
}
56
delay(100);
// After a short pause, LCD
// For LCD control needs
LcdCommandWrite(0x38); // Set to 8-bit interface, 2 line display, 5x7 text size
delay(64);
delay(50);
LcdCommandWrite(0x38); //Set to 8-bit interface, 2 line display, 5x7 text size
delay(20);
LcdCommandWrite(0x06); // Input mode setting
// Auto increment, no display shift
delay(20);
LcdCommandWrite(0x0E); // Display settings
// Turn on the display, the cursor shows, no flicker
delay(20);
LcdCommandWrite(0x01); // The screen is empty, the cursor position is zero
delay(100);
LcdCommandWrite(0x80); // Display settings
delay(20);
}
void loop (void) {

delay(10);
LcdCommandWrite(0x80+3);
delay(10);
LcdDataWrite('W');
LcdDataWrite('e');
LcdDataWrite('l');
LcdDataWrite('c');
LcdDataWrite('o');
LcdDataWrite('m');
LcdDataWrite('e');
LcdDataWrite(' ');
LcdDataWrite('t');
LcdDataWrite('o');
delay(10);
LcdCommandWrite(0xc0+1); // Defines the cursor position as second rows and second positions
delay(10);
LcdDataWrite('g');
LcdDataWrite('e');
LcdDataWrite('e');
57
LcdDataWrite('k');
LcdDataWrite('-');
LcdDataWrite('w');
LcdDataWrite('o');
LcdDataWrite('r');
LcdDataWrite('k');
LcdDataWrite('s');
LcdDataWrite('h');
LcdDataWrite('o');
LcdDataWrite('p');
delay(5000);
delay(10);
LcdDataWrite('I');
LcdDataWrite(' ');
LcdDataWrite('a');
LcdDataWrite('m');
LcdDataWrite(' ');
LcdDataWrite('h');
LcdDataWrite('o');
LcdDataWrite('n');
LcdDataWrite('g');
LcdDataWrite('y');
LcdDataWrite('i');
delay(3000);
LcdCommandWrite(0x02); //Set the pattern for the new text to replace the old text, no new text display the
same place
delay(10);
LcdCommandWrite(0x80+5); //Defines the cursor position as the first line of the sixth position
delay(10);
LcdDataWrite('t');
LcdDataWrite('h');
LcdDataWrite('e');
LcdDataWrite(' ');
LcdDataWrite('a');
LcdDataWrite('d');
LcdDataWrite('m');
LcdDataWrite('i');
LcdDataWrite('n');
delay(5000);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
58
////////
int DI = 12;
int RW = 11;
int DB[] = {3, 4, 5, 6, 7, 8, 9, 10};//Use an array to define the pins needed by the bus
int Enable = 2;
void LcdCommandWrite(int value) {
// Define all pins
int i = 0;
for (i=DB[0]; i <= DI; i++) //Bus assignment
{
digitalWrite(i,value & 01);//Because the 1602 liquid crystal signal recognition is D7-D0 (not D0-D7), here is
used to reverse the signal.
value >>= 1;
}
delayMicroseconds(1); // delay1ms
delayMicroseconds(1); // delay 1ms
}
void LcdDataWrite(int value) {
// Define all pins
int i = 0;
digitalWrite(DI, HIGH);
digitalWrite(RW, LOW);
for (i=DB[0]; i <= DB[7]; i++) {
digitalWrite(i,value & 01);
value >>= 1;
}
delayMicroseconds(1); //delay 1ms
}
void setup (void) {
int i = 0;
for (i=Enable; i <= DI; i++) {
pinMode(i,OUTPUT);
59
}
delay(100);
// After a short pause, LCD
// For LCD control needs
delay(64);
delay(50);
LcdCommandWrite(0x38); //Set to 8-bit interface, 2 line display, 5x7 text size
delay(20);
LcdCommandWrite(0x06); //Input mode setting
// Auto increment, no display shift
delay(20);
LcdCommandWrite(0x0E); // Display settings
delay(20);
LcdCommandWrite(0x01); //The screen is empty, the cursor position is zero
delay(100);
LcdCommandWrite(0x80); //Display settings
delay(20);
}
void loop (void) {
delay(10);
LcdCommandWrite(0x80+3);
delay(10);
/ / write a welcome message
LcdDataWrite('W');
LcdDataWrite('e');
LcdDataWrite('l');
LcdDataWrite('c');
LcdDataWrite('o');
LcdDataWrite('m');
LcdDataWrite('e');
LcdDataWrite(' ');
LcdDataWrite('t');
LcdDataWrite('o');
delay(10);
LcdCommandWrite(0xc0+1); // Defines the cursor position as second rows and second positions.
delay(10);
LcdDataWrite('k');
LcdDataWrite('u');
60
LcdDataWrite('m');
LcdDataWrite('a');
LcdDataWrite('n');
LcdDataWrite('A');
LcdDataWrite('r');
LcdDataWrite('d');
LcdDataWrite('u');
LcdDataWrite('i');
LcdDataWrite('n');
LcdDataWrite('o');
LcdDataWrite('p');
delay(5000);
delay(10);
LcdDataWrite('I');
LcdDataWrite(' ');
LcdDataWrite('a');
LcdDataWrite('m');
LcdDataWrite(' ');
LcdDataWrite('k');
LcdDataWrite('u');
LcdDataWrite('m');
LcdDataWrite('a');
LcdDataWrite('n');
delay(3000);
LcdCommandWrite(0x02); /*Set the pattern for the new text to replace the old text, no new text display the
same place*/
delay(10);
LcdCommandWrite(0x80+5); //Defines the cursor position as the first line of the sixth position
delay(10);
LcdDataWrite('t');
LcdDataWrite('h');
LcdDataWrite('e');
LcdDataWrite(' ');
LcdDataWrite('a');
LcdDataWrite('d');
LcdDataWrite('m');
LcdDataWrite('i');
LcdDataWrite('n');
delay(5000);
}
4 Bit connection method
61
Under normal use, the 8 bit access to the basic Arduino digital port is full, and if you want to pick a few sensors on
the no port, and how to deal with this situation, we can use the 4 bit access method.
4 bit connection method of the hardware connection method as shown below
After the hardware connection, the following code is uploaded to the control panel to see the effect.
int LCD1602_RS=12;
int LCD1602_RW=11;
int LCD1602_EN=10;
int DB[] = { 6, 7, 8, 9};
char str1[]="Welcome to";
char str2[]="geek-workshop";
char str3[]="this is the";
char str4[]="4-bit interface";
62
void LCD_Command_Write(int command)

{
int i,temp;
digitalWrite( LCD1602_RS,LOW);
digitalWrite( LCD1602_RW,LOW);
digitalWrite( LCD1602_EN,LOW);
temp=command & 0xf0;

for (i=DB[0]; i <= 9; i++)
{
digitalWrite(i,temp & 0x80);
temp <<= 1;
}
digitalWrite( LCD1602_EN,HIGH);
temp=(command & 0x0f)<<4;

for (i=DB[0]; i <= 10; i++)
{
temp <<= 1;
}
}
void LCD_Data_Write(int dat)

{
int i=0,temp;
digitalWrite( LCD1602_RS,HIGH);
temp=dat & 0xf0;

for (i=DB[0]; i <= 9; i++)
{
temp <<= 1;
}
63
temp=(dat & 0x0f)<<4;

for (i=DB[0]; i <= 10; i++)
{
temp <<= 1;
}
}
void LCD_SET_XY( int x, int y )

{
int address;
if (y ==0) address = 0x80 + x;
else address = 0xC0 + x;
LCD_Command_Write(address);
}
void LCD_Write_Char( int x,int y,int dat)

{
LCD_SET_XY( x, y );
LCD_Data_Write(dat);
}
void LCD_Write_String(int X,int Y,char *s)

{
LCD_SET_XY( X, Y ); //Set address
while (*s) //Write string
{
LCD_Data_Write(*s);
s ++;
}
}
void setup (void)

{
int i = 0;
64
for (i=6; i <= 12; i++)
{
pinMode(i,OUTPUT);
}
delay(100);
LCD_Command_Write(0x28);//4 lines and 2 lines 5x7
delay(50);
LCD_Command_Write(0x06);
delay(50);
LCD_Command_Write(0x0c);
delay(50);
delay(50);
delay(50);
void loop (void)

{
delay(50);
LCD_Write_String(3,0,str1);/First lines, fourth addresses
delay(50);
LCD_Write_String(1,1,str2);/Second lines, second addresses
delay(5000);
delay(50);
LCD_Write_String(0,0,str3);
delay(50);
delay(5000);

}
Common view copy code to save code print code
int LCD1602_RS=12;
int LCD1602_RW=11;
int LCD1602_EN=10;
int DB[] = { 6, 7, 8, 9};
char str1[]="Welcome to";
char str2[]="KUMAN Arduino";
char str3[]="this is the";
char str4[]="4-bit interface";
65
void LCD_Command_Write(int command)
{
int i,temp;
digitalWrite( LCD1602_RS,LOW);
temp=command & 0xf0;
for (i=DB[0]; i <= 9; i++)
{
temp <<= 1;
}

temp=(command & 0x0f)<<4;
for (i=DB[0]; i <= 10; i++)
{
temp <<= 1;
}
}
void LCD_Data_Write(int dat)
{
int i=0,temp;
digitalWrite( LCD1602_RS,HIGH);
temp=dat & 0xf0;
for (i=DB[0]; i <= 9; i++)
{
temp <<= 1;
}
66
temp=(dat & 0x0f)<<4;
for (i=DB[0]; i <= 10; i++)
{
temp <<= 1;
}
}
void LCD_SET_XY( int x, int y )
{
int address;
if (y ==0) address = 0x80 + x;
else address = 0xC0 + x;
LCD_Command_Write(address);
}
void LCD_Write_Char( int x,int y,int dat)
{
LCD_SET_XY( x, y );
LCD_Data_Write(dat);
}
void LCD_Write_String(int X,int Y,char *s)
{
LCD_SET_XY( X, Y ); //Set address
while (*s) / /Write string
{
LCD_Data_Write(*s);
s ++;
}
}
void setup (void)
{
int i = 0;
for (i=6; i <= 12; i++)
67
{
pinMode(i,OUTPUT);
}
delay(100);
LCD_Command_Write(0x28);//4 lines and 2 lines 5x7
delay(50);
delay(50);
LCD_Command_Write(0x0c);
delay(50);
delay(50);
delay(50);
void loop (void)
{
delay(50);
LCD_Write_String(3,0,str1);//First lines, fourth addresses from
delay(50);
LCD_Write_String(1,1,str2);//Second lines, second addresses from
delay(5000);
delay(50);
delay(50);
delay(5000);

}
Lesson 10 74HC595 experiment

74HC595 is simply said to the displacement of 8 bit registers and a memory, and three state output function. Here
we use it to control 8 LED lights. Why should we used 74HC595 to control lights? There must be many friends ask
this question, I would like to ask if we simply use an Arduino controls 8 lights to be occupied by the number of I /
68
O?? The answer is eight, but our Arduino 168 have several I / O port?? with analog interface is 20., the eight lights
occupied too many resources, we 74HC595 is to reduce use of the number of I / O port. With 74HC595, we can
use three digital I / O port to control 8 LED lights. Wouldn't it be wonderful, too?
Here are the components that we need to prepare.
In 74HC595 chip *1
The red line M5 LED*4
The green line M5 LED*4
220 ohm line resistance *8
Bread board *1
Bread board jumper *1 tie

We are ready to connect the circuit according to the schematic below.
Note: OE 74HC595 feet, to connect to the GND.
69
Note: OE 74HC595 feet, to connect to the GND.

This circuit is seemingly complex, we will find it very easy to find a reference in kind after careful analysis.
The following is a reference to source program:
int data = 2;//74HC595 14 pin data input pin SI
int clock = 5;//74HC595 11 pin clock line SCK
int latch = 4;//74hc595 12 pin output memory latch line RCK
int ledState = 0;
const int ON = HIGH;
const int OFF = LOW;
void setup()
{
pinMode(data, OUTPUT);
pinMode(clock, OUTPUT);
pinMode(latch, OUTPUT);
}
void loop()
{
for(int i = 0; i < 256; i++)
{
updateLEDs(i);
delay(500);
}
}
70
void updateLEDs(int value)
{
digitalWrite(latch, LOW);//
shiftOut(data, clock, MSBFIRST, ~value);//Serial data output, high priority
digitalWrite(latch, HIGH);//Latch
}
You can see 8 lights flashing beautiful scene download program.
The experimental phenomenon is to see the eight bit LED display eight bit binary number, loop self plus 1
Lesson 11 digital tube display experiment

Digital tube is a common display digital display, daily life, for example: electromagnetic oven, full automatic
washing machine, solar water temperature display, electronic clock... And so on the number of not very few. To
control the display of digital control principle, it is necessary to
The cathode of field digital tube, digital tube display digital tube is a kind of semiconductor light emitting devices,
the basic unit is the light-emitting diode, digital tube according to the number of segments is divided into seven
segment digital tube and eight digital tube, eight digital tube than seven segment digital tube more than a light
emitting diode unit (more than one decimal point), the use of eight digital tube. According to the light emitting
diode unit connection mode is divided into common anode and cathode nixie tube. Yang digital tube is refers to
all the light emitting diode anode received together form a common anode (COM) digital tube anode in the
application should be public com received + 5V, when a light emitting diode for low electricity at ordinary times
When a field of cathode for high electric power, the corresponding field is not bright. Common cathode digital
tube is all led to form a common cathode (COM) digital tube. Common cathode digital tube in the application
should be COM to the ground GND, when a field light-emitting diode anode for high power, the corresponding
field is lit. When a field of anode for low power, the corresponding field is not bright.
Each of the digital tube is composed of light-emitting diodes, so when using the same as the light-emitting diode,
but also to connect the current limit resistance, otherwise the current will burn the light emitting diode. This
experiment with a common cathode digital tube, common cathode digital tube in the application should be GND,
when a field light-emitting diode anode for low power, the corresponding field points out,
We begin to prepare the experimental components。
Eight segment digital tube *1
71
Bread board *1 bread board jumper *1 tie
We refer to the physical connection diagram to connect the circuit according to the schematic diagram.
72
Digital control of a total of seven sections show the number of segments, there is a display of the decimal point.
When the digital tube display digital, as long as the corresponding period of light can be. For example: the digital
tube display digital 1, C, B section will be lit. In the main program every 2S display a number, 1 to 8 digital display.
Reference source code:
//Set pin control all digital IO
int a=7;//Definition of digital interface 7 connected a segment digital tube
int b=6;// Definition of digital interface 6 connected B segment digital tubeint c=5;// Definition of digital interface
5 connected C segment digital tube
int d=10;// Definition of digital interface 10 connected D segment digital tube
int e=11;// Definition of digital interface 11 connected e segment digital tube
int f=8;// Definition of digital interface 8 connected f segment digital tube
int g=9;// Definition of digital interface 9 connected g segment digital tube
int dp=4;// Definition of digital interface 4 connected DP segment digital tube
void digital_0(void) //Display number 5
{
unsigned char j;
digitalWrite(a,HIGH);
digitalWrite(b,HIGH);
digitalWrite(c,HIGH);
73
digitalWrite(d,HIGH);
digitalWrite(e,HIGH);
digitalWrite(f,HIGH);
digitalWrite(g,LOW);
digitalWrite(dp,LOW);
}
{
unsigned char j;
digitalWrite(c,HIGH);//Digital interface to the 5 pin high, lit C segment
digitalWrite(b,HIGH);//Light B segment
for(j=7;j<=11;j++)//Extinguish the rest
digitalWrite(j,LOW);
digitalWrite(dp,LOW);//Put out the DP segment of the decimal point
}
{
unsigned char j;
for(j=9;j<=11;j++)
digitalWrite(j,HIGH);
digitalWrite(c,LOW);
digitalWrite(f,LOW);
}
void digital_3(void) //Display number3
{
digitalWrite(g,HIGH);
digitalWrite(f,LOW);
digitalWrite(e,LOW);
}
{
74
digitalWrite(a,LOW);
digitalWrite(e,LOW);
digitalWrite(d,LOW);
}
{
unsigned char j;
digitalWrite(b, LOW);
digitalWrite(e, LOW);
}
{
unsigned char j;
for(j=7;j<=11;j++)
digitalWrite(b,LOW);
}
void digital_7(void) //Display number7
{
unsigned char j;
for(j=5;j<=7;j++)
for(j=8;j<=11;j++)
digitalWrite(j,LOW);
}
{
unsigned char j;
for(j=5;j<=11;j++)
}
{
unsigned char j;
75
}
void setup()
{
int i;//defined variable
for(i=4;i<=11;i++)
pinMode(i,OUTPUT);//Set the 11 to 4 pin for the output mode
}
void loop()
{
while(1)
{
digital_0();//Display number 1
delay(1000);//delay 1s
delay(1000);//delay 1s
digital_2();//Display number2
delay(1000); //delay 1s
}
}
76
Experimental phenomenon: digital tube display 0-9 cycle display.
Lesson12 Four bit digital tube

This experiment is the use of Arduino to drive a total of four digital tube. The limit of the flow resistance is
essential to drive the digital tube, the current limit resistor has two kinds of connection, a total of 4 D1-D4. This
connection is less demand resistance, but will produce a different number of digital brightness will not be the
same, 8 of the most dark. This method is the other 8 pin, the brightness of the same, but with more resistance
220 100 8 ohm resistor, so use 220 instead of 10. 0 ohm brightness will be relatively high.
4 digital tube a total of 12 pins, the decimal point is placed in front of the bottom, the lower left corner of the 1,
the other pins in the order of the counterclockwise rotation. The upper left corner for the largest 12 pin.
77
The following figureManual of digital tube
The following is a hardware connection diagram
78
Here is the program；
//display 1234
//Set cathode interface
int a = 1;
int b = 2;
int c = 3;
int d = 4;
int e = 5;
int f = 6;
int g = 7;
int dp = 8;
//Set anode interface
int d4 = 9;
int d3 = 10;
int d2 = 11;
int d1 = 12;
//Set variable
long n = 1230;
int x = 100;
int del = 55; //Here to fine tune the clock
void setup()
{
pinMode(d1, OUTPUT);
79
pinMode(a, OUTPUT);
pinMode(b, OUTPUT);
pinMode(c, OUTPUT);
pinMode(d, OUTPUT);
pinMode(e, OUTPUT);
pinMode(f, OUTPUT);
pinMode(g, OUTPUT);
pinMode(dp, OUTPUT);
}
/////////////////////////////////////////////////////////////
void loop()
{
Display(1, 1);
Display(2, 2);
Display(3, 3);
Display(4, 4);
}
///////////////////////////////////////////////////////////////
void WeiXuan(unsigned char n)//
{
switch(n)
{
case 1:
digitalWrite(d1,LOW);
digitalWrite(d2, HIGH);
break;
case 2:
digitalWrite(d2, LOW);
break;
case 3:
digitalWrite(d1,HIGH);
break;
case 4:
80
break;
default :
break;
}
}
void Num_0()
{
digitalWrite(a, HIGH);
digitalWrite(b, HIGH);
digitalWrite(c, HIGH);
digitalWrite(d, HIGH);
digitalWrite(e, HIGH);
digitalWrite(f, HIGH);
digitalWrite(g, LOW);
}
void Num_1()
{
digitalWrite(a, LOW);
digitalWrite(d, LOW);
digitalWrite(f, LOW);
}
void Num_2()
{
digitalWrite(c, LOW);
digitalWrite(g, HIGH);
81
}
void Num_3()
{
}
void Num_4()
{
}
void Num_5()
{
}
void Num_6()
{
82
}
void Num_7()
{
}
void Num_8()
{
}
void Num_9()
{
}
void Clear() // Clear the screen
{
digitalWrite(c, LOW);
83
}
void pickNumber(unsigned char n)//Choose the number of
{
switch(n)
{
case 0:Num_0();
break;
case 1:Num_1();
break;
case 2:Num_2();
break;
case 3:Num_3();
break;
case 4:Num_4();
break;
case 5:Num_5();
break;
case 6:Num_6();
break;
case 7:Num_7();
break;
case 8:Num_8();
break;
case 9:Num_9();
break;
default:Clear();
break;
}
}
void Display(unsigned char x, unsigned char Number)//Show that x is the coordinate, Number is the number
{
WeiXuan(x);
pickNumber(Number);
delay(1);
Clear() ; //Vanishing
}
Copy the following code to download to the control panel to see the effect chart.
84
Experimental results for digital tube display 1234,
Note: the connection when the need for patience, careful, not even any wrong line, when garbled, first check the
line.
Lesson13 Hit module
85
Hit Temperature module can connect UNO R3 PIN13, make hit test.
Pin 13’s LED，use hit module connect Pin 3. When hit module test there is hit, led can be bright.
Wiring diagram:
Components
-1 * KUMAN Uno board
- 1 * Tap on a module
- 1 * Jumper wires
86
Code：
int Led=13;//Define LED interface
int Shock=3//Define vibration sensor interface
int val;//Define numeric variable val
void setup()
{
pinMode(Led,OUTPUT);//Define LED as output interface
pinMode(Shock,INPUT);//Define vibration sensor as output interface
}
void loop()
{
val=digitalRead(Shock);//Read the value of the value of the digital interface 3 to val
if(val==HIGH)//When the vibration sensor detects the signal, the LED flashes
{
digitalWrite(Led,LOW);
}
else
{
digitalWrite(Led,HIGH);
}
}
Lesson14 Tilt-Switch
Introduction
The tilt switch used here is a ball one with a metal ball inside. It is used to detect the small angle of
inclination.
Components
- 1 * Kuman Uno board
- 1 * Tilt switch
- Several jumper wires
The principle is very simple. When the switch tilts in a certain angle, the inside ball rolls down and
touches the two contacts which is connected to the outside pins, thus triggering circuits. Otherwise
the ball will stay away from the contacts, thus breaking the circuits.
87
88
Now, tilt the switch, and the LED attached to pin 13 on Kuman Uno board will light up.
89
Code
//tilt switch
//tilt the switch, and the LED attached to pin 13 on SunFounder Uno board will light up.
//tilt switch attach to pin2
//Email: [email protected]
//Website: www.sunfounder.com
/*****************************************/
const int ledPin = 13;//the led attach to
void setup()
{
pinMode(ledPin,OUTPUT);//initialize the ledPin as an output
pinMode(2,INPUT);//set pin2 as INPUT
digitalWrite(2, HIGH);//set pin2 as HIGH
}
/******************************************/
void loop()
{
int digitalVal = digitalRead(2);//Read the value of pin2
if(HIGH == digitalVal)//if tilt switch is not breakover
{
digitalWrite(ledPin,LOW);//turn the led off
}
else ////if tilt switch breakover
{
digitalWrite(ledPin,HIGH);//turn the led on
}
}
/*****************/
Lesson15 ultrasonic distance measuring module

This module has stable performance, accurate measurement range, and can be compared with
foreign SRF05, SRF02 and other ultrasonic ranging module. Module high precision, blind area (2cm)
ultra near, stable ranging is the product of this product successfully to the market!
Experimental components
Arduino control board *1
USB line *1
Ultrasonic *1
90
Main technical parameters: the use of voltage: DC5V, static current: less than 2mA level output:
high 5V, level output: bottom 0V, induction angle: no more than 15 degrees, detection range: 2cm-
450cm, high accuracy of up to 0.2cm
Connection mode, VCC, trig (control side), echo (receiver), GND
Note:1.the module should not be charged connection, if you want to live connection, let the first
module of the GND connection, otherwise it will affect the normal operation of the module.
2, ranging, the area of the measured object is not less than 0.5 square meters and the plane as far
as possible to level, otherwise the results of the measurement.
Program source code：
91
const int TrigPin = 2;
const int EchoPin = 3;
float cm;
void setup()
{
Serial.begin(9600);
pinMode(TrigPin, OUTPUT);
pinMode(EchoPin, INPUT);
}
void loop()
{
digitalWrite(TrigPin, LOW); //Low high and low level to send a short pulse to TrigPin
digitalWrite(TrigPin, HIGH);
digitalWrite(TrigPin, LOW);
cm = pulseIn(EchoPin, HIGH) / 58.0; //The echo time is converted into cm

cm = (int(cm * 100.0)) / 100.0; //Keep two decimal places
Serial.print(cm);
Serial.print("cm");
Serial.println();
delay(1000);
}
Introduction
Ultrasonic ranging module HC - SR04 provides 2cm - 700cm non-contact measurement function,
the ranging accuracy can reach to 3mm.Ensured stable signal within 5m, gradually faded signal
outside 5m till disappearing at 7m position.
The modules includes ultrasonic transmitters, receiver and control circuit. The basic principle of
work:
(1) Using IO trigger for at least 10us high level signal；
(2) The Module automatically sends eight 40 kHz and detect whether there is a pulse signal back.
(3) IF the signal back, through high level , time of high output IO duration is the time from sending
ultrasonic to returning. Test distance = (high level time×velocity of sound (340M/S) / 2.
Pin Function:
92
TRIG: Trigger Pulse Input
ECHO: Echo Pulse Output
GND: Ground
VCC: 5V Supply
Features
Working Voltage DC5V
Working Current 16mA
Working Frequency 40Hz
Max Range 700cm, Ensured stable signal within 5m, gradually faded signal outside 5m till
disappearing at 7m position.
Min Range 2cm
Trigger Input Signal 10uS TTL pulse
Echo Output Signal Input TTL lever signal and the range in proportion
Dimension 46x20.5x15 mm
Pricinple:
The Timing diagram is shown below. You only need to supply a short 10uS pulse to the trigger input
to start the ranging, and then the module will send out an 8 cycle burst of ultrasound at 40 kHz and
raise its echo. The Echo is a distance object that is pulse width and the range in proportion .You can
calculate the range through the time interval between sending trigger signal and receiving echo
signal. Formula: uS / 58 = centimeters or uS / 148 =inch; or: the range = high level time * velocity
(340M/S) / 2; we suggest to use over 60ms measurement cycle, in order to prevent trigger signal to
the echo signal.
93
Test Code:
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#define Echo 11 //Echo connnect to pin11
#define Trig 12 //Trig connect to pin12
unsigned long rxTime; //define a variable
float distance;
LiquidCrystal_I2C lcd(0x27,16,2);
void setup()
// put your setup code here, to run once:
Serial.begin(115200); //set the baud rate of serial monitor
pinMode(Echo,INPUT);
94
pinMode(Trig,OUTPUT);
lcd.init(); // initialize the lcd
// Print a message to the LCD.
lcd.backlight(); //turn o the backlight
lcd.setCursor(0, 0); //set the cursor on 0 row,0 col
lcd.print("Ping:"); //print the "Ping: "on the LCD
void loop()
// Generates a pulse
digitalWrite(Trig, HIGH);
digitalWrite(Trig, LOW);
rxTime = pulseIn(Echo, HIGH); //read the Receive time
// Serial.print("rxTime:");
// Serial.println(rxTime);
distance = (float)rxTime * 34 / 2000.0; //Converted into a distance ,cm
if(distance < 800 ) //filter interference signal
Serial.print("distance:");
Serial.print(distance); //print it the distance in serial monitor
95
Serial.println("CM");
lcd.setCursor(6, 0);
lcd.print(distance);//print it in LCD1602
lcd.print("CM");
delay(100);
Lesson16 thermal resistance

1：Introduction of thermistor
Thermistor's resistance to temperature sensitive a resistor, also called semiconductor thermistor. It can be by
single crystal, polycrystalline and glass, made of semiconductor materials such as plastic. This resistor has a series
of special electrical properties, the basic characteristics is the resistance changes with temperature has a very
significant changes, and volt ampere curve is nonlinear.
2：main features
On the high temperature sensitivity, thermal inertia of small, long life, small volume, simple structure and made of
various kinds of different shape and structure. Therefore, with the development of industrial and agricultural
production, science and technology, this element has been widely used, such as temperature measurement,
temperature control, temperature compensation, liquid level measurement, pressure measurement, fire alarm,
meteorological sounding, the switch circuit, overload protection, suppress voltage fluctuation, time delay,
amplitude stability, automatic gain adjustment, laser and microwave power measurement and so on.
3：characteristic parameter
The main characteristic parameters of the thermistor are the resistance temperature characteristic, the voltage
current characteristic and the thermal time constant.
4：Connection method
96
5：Test code
void setup() {
// initialize serial communication at 9600 bits per second:
Serial.begin(9600);
}
// the loop routine runs over and over again forever:

void loop() {
// read the input on analog pin 0:
int sensorValue = analogRead(A0);
// print out the value you read:
Serial.println(sensorValue);
delay(1); // delay in between reads for stability
}
The above code onto your board, open the serial port window, you can see the following：
97
Lesson17 step motor test

Stepping motor is a kind of electric pulse into the angular displacement of the executive body. Popular point of
view: when the stepper driver receives a pulse signal, it drives the stepper motor according to set the direction of
rotation of a fixed angle (and step angle). You can control the angular displacement by controlling the number of
pulses and you can control the the motor rotation speed and acceleration by controlling the pulse frequently, so
as to achieve the goal.
The following is the experimental use of the stepper motor
98
2011-9-6 17:20:53 上传
下载附件 (130.89 KB)
2011-9-6 17:42:20 上传
下载附件 (64.19 KB)
Before using the stepper motor please carefully check the specification, to confirm that the four phase or two
phases, how to connect the various lines, this experiment used the stepper motor is the four phase, the different
colors of the line is defined as follows
picture：
99
Slow stepping motor

Diameter: 28mm
Voltage: 5V
Step angle: 5.625 1/64 x
Reduction ratio: 1/64
5 line 4 phase can be used with ordinary ULN2003 chip driver, can also be connected to the use of 2 phase

The step into the motor no-load power consumption below 50mA, with 64 times the speed reducer, torque
output can drive heavy load, is very suitable for the development board to use. Note: the stepper motor with 64
times the speed reducer, and without reduction of stepper motor compared, speed is slower, is easy for
observation, the output shaft stick a piece of cardboard.
100
Step motor (five line four phase) driving board (UL2003) test board
Stepping motor drive board (UL2003) test board
101
external SIZE：31×35mm
The hardware connection diagram is as follows
2011-9-5 23:06:50 上传
102
下载附件 (126.87 KB)
Download the code to the Arduino control panel to see the results.
/*
* Stepper motor with potentiometer rotation
* (or other sensors) using 0 analog inputs
* Use IDE Stepper.h comes with the Arduino library file
#include <Stepper.h>
// Here to set the stepper motor rotation is how many steps
#define STEPS 100
// attached toSet the step number and pin of the stepper motor
Stepper stepper(STEPS, 8, 9, 10, 11);
// Define variables used to store historical readings
int previous = 0;
void setup()
{
// Set the motor at a speed of 90 steps per minute
stepper.setSpeed(90);
}
void loop()
{
int val = analogRead(0); // Get sensor readings
stepper.step(val - previous);// Move the number of steps for the current readings less historical readings
previous = val;// Save historical readings }
Experimental results: the slow rotation of the stepper motor。

1.
2. /*
3. * 步进电机跟随电位器旋转
4. * (或者其他传感器)使用 0 号模拟口输入
5. * 使用 arduino IDE 自带的 Stepper.h 库文件
6. */
7.
8. #include <Stepper.h>
9.
10. // 这里设置步进电机旋转一圈是多少步
11. #define STEPS 100
12.
13. // attached to 设置步进电机的步数和引脚
14. Stepper stepper(STEPS, 8, 9, 10, 11);
15.
16. // 定义变量用来存储历史读数
17. int previous = 0;
18.
103
19. void setup()
20. {
21. // 设置电机每分钟的转速为 90 步
22. stepper.setSpeed(90);
23. }
24.
25. void loop()
26. {
27. // 获取传感器读数
28. int val = analogRead(0);
29.
30. // 移动步数为当前读数减去历史读数
31. stepper.step(val - previous);
32.
33. // 保存历史读数
34. previous = val;
35. }
‘
Lesson18 steering gear control experiment

Steering gear is a kind of position servo drive, is mainly composed of a casing, a circuit board, non - core motor,
gear and position detector. Its working principle is by the receiver or the SCM sends signals to the servo and the
internal have a benchmark circuit, generating cycle for 20ms, width of 1.5ms reference signal, will get the DC bias
voltage and the potentiometer voltage compared with that obtained from the voltage difference output. Through
the IC circuit board judge the direction of rotation, and then drive - core motor starts to rotate, through the
reduction gear, the power is transmitted to the swing arm, also by a position detector back to signal, judge
whether it has already reached the location. It is suitable for the The control system which needs to be changed
and can be kept in a certain degree. When the motor speed is certain, the potentiometer is rotated by a cascade
speed reduction gear, the voltage difference is 0, the motor stops rotating, and the angle range of the
104
generalsteering gear rotation is 0 degrees to 180 degrees.

Servo there are many specifications, but all the steering gear has an external three lines, respectively, with brown,
red, orange three colors to distinguish, because the steering gear brand is different, the color will be different,
brown for the ground wire, red for the positive wire, orange signal line.
Steering angle is adjusted PWM (pulse width modulation) signal duty cycle to achieve, standard PWM (pulse
width modulation) signal cycle is fixed to 20ms (50Hz), pulse width distribution should be between 1ms to 2ms,
but in fact pulse width can be from 0.5ms to 2.5ms, pulse width and steering angle of 0 degrees to 180 degrees.
There is a point worth noting, because the steering gear brand is different, for the same signal, different brands of
steering angle will be different.
105
After knowing the basic knowledge we can learn to control a servo motor, components of the experiments
required rarely need only steering gear A and a jumper bar can be.。
RB - 412 steering gear *1

The steering gear with Arduino method has two kinds, one is through the Arduino common digital sensor
interface to produce a different duty cycle of Fang Bo, analog PWM signal steering, second is the direct use of
Servo function Arduino function for steering control, the advantages of this control method is to control the 2 way
steering gear, because the Arduino comes with a function only the use of digital 9,10 interface.Arduino drive
ability is limited, need to control more than 1 of the steering gear The source.。
One method
106
The steering gear is connected to the digital 9 interface.
Write a program to turn the steering gear to the user input number corresponding to the number of degrees of
the position, and the angle of the print display to the screen.
Reference to source program A:、

Int servopin=9; / / define digital interface 9 connected servo signal line
Int myangle; / / define the angle variable
Int pulsewidth; / / define variable pulse widthint val;

void servopulse(int servopin,int myangle)//Define a pulse function
{
pulsewidth=(myangle*11)+500;//The pulse width of 500-2480 is converted into the pulse width.
digitalWrite(servopin,HIGH);//The rudder interface level is high
delayMicroseconds(pulsewidth);//Time delay pulse width
digitalWrite(servopin,LOW);//Servo interface level to low
delay(20-pulsewidth/1000);
}
void setup()
107
{
pinMode(servopin,OUTPUT);//Set steering interface for output interface
Serial.begin(9600);//Connected to the serial port, the baud rate is 9600
Serial.println("servo=o_seral_simple ready" ) ;
}
void loop()//The number of 0 to 0 is converted to a 9 - to 180 angle, and the number of the corresponding
number of LED flashes
{
val=Serial.read();//Read the value of the serial port
if(val>'0'&&val<='9')
{
Val=val-'0'; / / the features into numerical variables
Val=val* (180/9); / / digital into perspective

Serial.print("moving servo to ");
Serial.print(val,DEC);
Serial.println();
for(int i=0;i<=50;i++) //Give the steering gear enough time to let it go to the specified angle.
{
servopulse(servopin,val);//Reference pulse function
}
}
}
Method two
First detailed analysis of the Arduino comes with the Servo function and its statements, to introduce some of the
common statements of the rudder function.
1、attach(Interface) - to set the steering gear interface, only the number 9 or 10 interface can be used.
2、Write (angle) - to set the steering angle of the steering angle of the steering gear can be set from the angle
range is 0 degrees to 180 degrees.
3、Read () - a statement that reads the steering angle of the steering gear can be understood as the value of the
last write () command.
4、attached （） — — To determine whether the steering gear parameters have been sent to the actuator
interface。
5 、 detach （） — — The steering gear is separated from its interface, and the interface (number 9 or 10) can
continue to be used as a PWM interface.。
Note: the above statement is written in the format of the actuator variable name. The specific statement (), for
example: myservo.attach (9).
The steering gear is still connected to the digital 9 interface.Reference to source program B:
<Servo.h>// #include header files, there is a point to pay attention, you can directly in the Arduino software menu
bar click Sketch>Importlibrary>Servo, call the Servo function, you can directly enter the <Servo.h> #include, but in
the input should pay attention to between #include and <Servo.h> to have a space, or compile time will be
reported to the wrong.
Servo myservo; / / define servo variable name
void setup()
108
{
myservo.attach(9);//Definition of steering gear interface (9,10 can, shortcomings can only control 2)
}
void loop()
{
myservo.write(90);//Set the steering angle of the steering gear.
}
Above is to control the steering gear of the two methods, each has its own advantages and disadvantages of each
according to their own preferences and needs to be chosen.
Lesson19 photosensitive lamp experiment

Upon completion of the above experiments, we should have some understanding of the application of Arduino, in
the basic digital input and output and analog input and PWM generation are mastered, we can begin some of the
application of the sensor. Photosensitive resistor photovaristor called light perception in resistance, is made of
using semiconductor photoelectric effect a resistance value with the incident light intensity and change the
resistor; incident light intensity, reducing resistance, weak light incident, resistance increases. Photosensitive
resistors are generally used for optical measurement, light control and photoelectric conversion (the light
variation is converted to electrical variations).
The photosensitive resistor can be widely used in various optical circuit, such as lighting control, regulation and
other occasions, can also be used for the light switch.
In this experiment, we first carry out the use of a relatively simple photosensitive resistance test. Photosensitive
resistance since it is can according to changes in light intensity resistance element, natural need to simulate the
port to read analog value. This experiment can reference PWM interface experiment, the potentiometer for
photosensitive resistance when the light intensity and the brightness of the LED lights will have corresponding
change.
The following is the required components：
Photosensitive resistor *1
109
The red line M5 LED*1
10K line resistance *1
Bread board *1

According to the following schematic connection circuit.
110
Connected to the program can be written, the experimental program and the PWM test program is similar to the
PWM value in the value of the assignment, according to our current circuit slightly modified (modified part see
reference to source program).
Reference source program：
int potpin=0;//Define the analog interface 0 connect the photosensitive resistance
int ledpin=11;//Define digital interface 11 output PWM adjust LED brightness
int val=0;//Defined variable val
void setup()
{
pinMode(ledpin,OUTPUT);//Define digital interface 11 for output
Serial.begin(9600);//Set the baud rate to 9600
}
void loop()
{
val=analogRead(potpin);//Read the sensor's analog values and assign to val
Serial.println(val);//Display Val variable value
analogWrite(ledpin,val);// Turn on the LED and set the brightness (the maximum value of the PWM output is 255)
delay(10);//Delay 0.01 seconds
}
Here we return sensor values divided by 4. The reason is that the analog input analogRead () function returns the
value of the range is 0 to 1023, and simulation output analogwrite () function of the output value range is 0 to
255. Downloaded program and try to change the intensity of the environment where the photosensitive
resistance can see our lights there are corresponding changes. In the daily life of photosensitive resistance
application is very extensive of, usage is also a lot of, we can
111
According to the experimental analogy, make interactive works better.
Lesson20 LM35 Temperature Sensor
Introduction
LM35 is a temperature sensor produced by National Semiconductor. It has very high operational
accuracy and a wide operating range. With small size, low cost and reliability, LM35 is widely
applied in engineering. Since it uses internal compensation, the output can begin with 0 ℃. LM35
has many different packages. Under the normal temperature, the LM35 requires no additional
calibration to reach the accuracy of plus or minus 1/4 ℃. The power supply mode can be classified
as single power source and positive-and-negative double power supply. Its pins are as shown
below.Under the positive-and-negative dual power supply mode, it can measure a negative
temperature. Under the single power supply mode and 25℃, the quiescent current is about 50μA
and it has a wide operation voltage range - between 4 to 20V, thus saving electricity.
112
Components
- 1* KUMAN Uno board
- 1 * Breadboard
- 1 * LM35 Temperature Sensor
- 1 * I2C LCD1602
- Several jumper wires
The output voltage of the LM35 is proportional to Celsius temperature. When placed in 0 ℃
ambient temperature, it will output 0V. The output voltage will increase 10mV every time when the
temperature increases by 1℃. The calculation formula is as follows:
113
Note: Here you need to add a library. Refer to the file LiquidCrystal_I2C
Now, you can see the current temperature displayed on the I2C LCD1602.
114
/*****************************************
* name:LM35 Temperature Sensor
* function:
* LM35 output voltage has a linear relation with the Celsius temperature, output of 0 v when 0 ℃,
* every increase 1 ℃, the output voltage increase 10 mv
*****************************************/
//lm35 attach to A0
/****************************************/
#define lmPin A0 //LM35 attach to
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27,16,2); // set the LCD address to 0x27 for a 16 chars and 2 line display
float tem = 0;
long lmVal = 0;
void setup()
{
lcd.init(); //initialize the lcd
lcd.backlight(); //open the backlight
}
void loop()
{
lmVal = analogRead(lmPin);//read the value of A0
tem = (lmVal * 0.0048828125 * 100);//5/1024=0.0048828125;1000/10=100
lcd.setCursor(5,0);//place the cursor on 5 column,0 row
115
lcd.print("LM35");//print"LM35"
lcd.print("Tem= ");//print"Tem= "
lcd.print(tem);//print tem
lcd.print(char(223));//print the unit" ℃ "
lcd.print("C");
delay(200);//delay 200ms}
Lesson21 LED Scintillation test

LED lights experiment is one basis of comparison experiments, experiment has been used to bring the Arduino
led, this time we use other I / O port and then dip LED lights to finish the experiment, we need experimental
equipment in addition to each experiment must be the Arduino controller and USB download cable.
The list of components used in the experiment is as follows:
1. Red M5 LED 1 pcs
2. 220Ωline resistance*1
116
3.bread board*1
4. Bread board jump line*1tie
The next step we in accordance with the following lights the principle graph links physical map. Here we use the
number 10 interface. Using light-emitting diode (LED), which is connected with a current limiting resistor, here is a
220 ohm resistor, or the current Congress burned light-emitting diodes.
The principle map lights:
117
Physicaldiagramconnectiondiagram:
In accordance with the above link circuit, you can start writing programs, we still allow the LED lights flashing, lit 1
seconds out 1 seconds. This procedure is very simple and the Arduino comes with routine in the blink similar just
13 digital interface for 10 digital interface.。
-----------------------------------------------------------
118
Reference procedures are as follows：
int ledPin = 10; //Define number 10 interface
void setup()
{
pinMode(ledPin, OUTPUT);//The definition of small interface for output interface
}
void loop()
{
digitalWrite(ledPin, HIGH); //Light the lamp
delay(1000); //Delay 1 seconds
digitalWrite(ledPin, LOW); //Lights out
delay(1000); //Delay 1 seconds
}
---------------------------------------------------------
Download program you can see our 10 small lights flashing in the mouth, so that we The experimental
phenomenon for the LED
flashing, the interval is about one
second.
Light flicker experiment is completed.
119
Lesson22 Infrared-Receiver
Introduction
An infrared-receiver is a component which receives infrared signals and can independently receive
infrared ray and output signals compatible with TTL level. It's similar to a normal plastic-packaged
transistor in size and suitable for all kinds of infrared remote control and infrared transmission.
Components
- 1 * Infrared-receiver module
- 1 * Remote controller
- 1 * 3-Pin anti-reverse cable
Control a certain key (for example, Power key) via a remote controller by programming. When you
press the key, infrared rays will be emitted from the remote control and received by the infrared
receiver, and the LED on the KUMAN Uno board will light up. Connect an LED to pin 13 on the
KUMAN Uno board so that you can see remotely whether the Power key is pressed down.
120
121
Note: Here you need to add a library. Refer to the description in LIBRARY
Now, press the Power key of a remote control, and both the LED attached and that connected to
pin 13 on the KUMAN Uno board will light up. Then press any key, the LEDs will light out.
122
1、Infrared receiving head introduction
一、What is the infrared receiver head?

From the infrared remote control signal is a series of binary pulse code. In order to make it
from other infrared signal interference in wireless transmission process, usually first its
modulation on the specific carrier frequency, and then by the infrared emitting diodes
emitted, and the infrared receiving device to filtering the clutter, they receive the specific
frequency signal and restore it to the binary pulse code, also is demodulation.
二、Working principle
The built-in receiver will transmit the infrared emission tube light signal into a weak signal,
this signal through the IC internal amplifier amplification, and then through the automatic
gain control, band-pass filtering, demodulation, waveform shaping after the original
encoding to restore the original signal output by the receiver signal output pin input to the
electrical appliances on the encoding recognition circuit.
三、Pin and connection of infrared receiving head
123
The infrared receiving head has three pins as follows:

When using the VOUT to the analog port, GND received the experimental board GND, +5v. received the VCC on
the experimental board
Infrared remote control experiment
1, experimental device
As for the infrared remote control: 1
Of the infrared receiving head: 1
The LED of light: 6
The 220 resistor: 6
The colorful line: some of the bread

2、Experimental connection
First, the board is connected; then the infrared receiver head in accordance with the above method, the
VOUT connected to the digital 11 pin, the LED lamp through the resistor connected to the digital pin
2,3,4,5,6,7. back to complete the circuit part of the connection.
3、Experimental principle
To decode a remote controller must be aware of the remote control of the encoding way. This product
is used to control the code of the way: NEC agreement. Following the introduction of the NEC protocol:
·NEC protocol description: features: (1) 8 address bits, 8 bit command
(two) for the 2 time in order to address the reliability address bit and the command bit
(3) pulse position modulation

(4) carrier frequency 38kHz
(5) each time for the 1.125ms ring 2.25ms
·Logic 0 and 1 are defined as follows.：
124
·Press the launch pulse at once:
The image above shows a typical pulse sequence of NEC. Note: this first send LSB (the most low)
protocol. In the above pulse transmission of the address for the 0x59 command 0x16. a message is from
a high level of 9ms, then there is a low level of 4.5ms, and the command code. The address and
command code. Second times all bits are taken back, can be used for the confirmation of the message.
Because every point and it takes anti length repeat, you can ignore the if you are not interested. Take
the counter, you can also expand the address and command, to every 16!
Key press a period of time before the release of the launch pulse：
A command sent once, even on the remote control button is still pressed. When the button has been
pressed, the first 110ms of the pulse and the image above, after each 110ms repeat code transmission.
·repetitive pulse
Note: pulse waveform of integration into the receiving head, because integration receiving head to disobey
decoding, signal amplifying and shaping, so pay attention to: in the absence of infrared signal, and the output end
of the signal for a high level to low level, so its output signal level just and a transmitting terminal are anti.
Receiving pulse end we can seen by the oscilloscope and see the waveform of program understanding.
Line connection diagram：

Program code：
#include <IRremote.h>
int RECV_PIN = 11;
125
int LED1 = 2;
int LED2 = 3;
int LED3 = 4;
int LED4 = 5;
int LED5 = 6;
int LED6 = 7;
long on1 = 0x00FFA25D;
long off1 = 0x00FFE01F;
long on2 = 0x00FF629D;
long off2 = 0x00FFA857;
long on3 = 0x00FFE21D;
long off3 = 0x00FF906F;
long on4 = 0x00FF22DD;
long off4 = 0x00FF6897;
long on5 = 0x00FF02FD;
long off5 = 0x00FF9867;
long on6 = 0x00FFC23D;
long off6 = 0x00FFB047;
IRrecv irrecv(RECV_PIN);
decode_results results;
// Dumps out the decode_results structure.
// Call this after IRrecv::decode()
// void * to work around compiler issue
//void dump(void *v) {
// decode_results *results = (decode_results *)v
void dump(decode_results *results) {
int count = results->rawlen;
if (results->decode_type == UNKNOWN)
{
Serial.println("Could not decode message");
}
else
{
if (results->decode_type == NEC)
{
Serial.print("Decoded NEC: ");
}
else if (results->decode_type == SONY)
{
Serial.print("Decoded SONY: ");
}
else if (results->decode_type == RC5)
{
Serial.print("Decoded RC5: ");
126
}
else if (results->decode_type == RC6)
{
Serial.print("Decoded RC6: ");
}
Serial.print(results->value, HEX);
Serial.print(" (");
Serial.print(results->bits, DEC);
Serial.println(" bits)");
}
Serial.print("Raw (");
Serial.print(count, DEC);
Serial.print("): ");
for (int i = 0; i < count; i++)

{
if ((i % 2) == 1) {
Serial.print(results->rawbuf[i]*USECPERTICK, DEC);
}
else
{
Serial.print(-(int)results->rawbuf[i]*USECPERTICK, DEC);
}
Serial.print(" ");
}
Serial.println("");
}
void setup()
{
pinMode(RECV_PIN, INPUT);
pinMode(LED1, OUTPUT);
pinMode(13, OUTPUT);
Serial.begin(9600);
irrecv.enableIRIn(); // Start the receiver

}
int on = 0;
unsigned long last = millis();
127
void loop()
{
if (irrecv.decode(&results))
{
// If it's been at least 1/4 second since the last
// IR received, toggle the relay
if (millis() - last > 250)
{
on = !on;
// digitalWrite(8, on ? HIGH : LOW);
digitalWrite(13, on ? HIGH : LOW);
dump(&results);
}
if (results.value == on1 )
digitalWrite(LED1, HIGH);
if (results.value == off1 )
digitalWrite(LED1, LOW);
last = millis();
irrecv.resume(); // Receive the next value
}
}
128
Lesson23 Potentiometer
A potentiometer is a simple knob that provides a variable resistance, which we can read into the
Arduino board as an analog value. In this example, that value controls the rate at which an LED
blinks.
We connect three wires to the Arduino board. The first goes to ground from one of the outer pins
of the potentiometer. The second goes from 5 volts to the other outer pin of the potentiometer.
The third goes from analog input 2 to the middle pin of the potentiometer.
By turning the shaft of the potentiometer, we change the amount of resistence on either side of
the wiper which is connected to the center pin of the potentiometer. This changes the relative
"closeness" of that pin to 5 volts and ground, giving us a different analog input. When the shaft is
turned all the way in one direction, there are 0 volts going to the pin, and we read 0. When the
shaft is turned all the way in the other direction, there are 5 volts going to the pin and we read
1023. In between, analogRead() returns a number between 0 and 1023 that is proportional to the
amount of voltage being applied to the pin.
Wiring diagram：
Components:
- 1 * USB cable
- 1 * 10 k adjustable resistance
129
- Jumper wires
- 1 * Big bread board
Code：
/* Analog Read to LED

* ------------------
*
* turns on and off a light emitting diode(LED) connected to digital
* pin 13. The amount of time the LED will be on and off depends on
* the value obtained by analogRead(). In the easiest case we connect
* a potentiometer to analog pin 2.
*/
int potPin = 2; // select the input pin for the potentiometer

int ledPin = 13; // select the pin for the LED
int val = 0; // variable to store the value coming from the sensor
void setup() {
pinMode(ledPin, OUTPUT); // declare the ledPin as an OUTPUT
}
void loop() {
val = analogRead(potPin); // read the value from the sensor
digitalWrite(ledPin, HIGH); // turn the ledPin on
delay(val); // stop the program for some time
digitalWrite(ledPin, LOW); // turn the ledPin off
delay(val); // stop the program for some time
}
Lesson 24 Analog temperature sensor
130
Description:
The temperature sensor is a NTC thermistor

Multi-point temperature measurement Measures temperatures: -55 째 C / +125 째 C
Accuracy: + / - 0.5 째 C
Material: mixed material
Dimensions: 3 x 1.5 x 0.6cm
Weight : 2g
131
Components
- 1 * USB cable
- 1 * Analog Temp module
- Jumper wires
- 1 * Breadboard
Test Code:
#include <math.h>
double Thermister(int RawADC) {
double Temp;
Temp = log(((10240000/RawADC) - 10000));
Temp = 1 / (0.001129148 + (0.000234125 + (0.0000000876741 * Temp * Temp ))* Temp );
132
Temp = Temp - 273.15; // Convert Kelvin to Celcius
return Temp;
}
void setup() {
Serial.begin(9600);
}
void loop() {
Serial.print(Thermister(analogRead(0))); // display Fahrenheit
Serial.println("c");
delay(500);
}
Thermistors are also can measure temperature, because it combines the Steinhart - Hart Thermistor equation, the
test code functions in the double Thermister (int RawADC) is just the embodiment of the equation.
Take a look at the experimental results:
The window is now shown in room temperature,

Ok, here we use hand touch it, see change will have no??????
133
The test completed successfully.
134
Lesson 25 Touch module
This is a direct use control switch module, when a finger touch screen printing
white circles, the SIG pin will output a high level, when fingers left, SIG pin
output low level.
Below is the connection mode:
Touch module Arduino

GND ---------------------------------- GND
VCC ---------------------------------- 5V
SIG ---------------------------------- D3
Below is the wiring diagram：
Components
135
- 1 * USB cable
- 1 * Touch module
- Jumper wires
- 1 * Breadboard
The experiment shows that:
Touch module in this experiment, we use D3 pin is high/low signal detection, when the D3 pin
signal is high, D13 pin is high, when the D3 pin signal is low, D13 pin is low. Here we choose "D13
pin" because the pin come with the LED on the main board.
Test code:
int Led=13;// Define LED interface

int touch=3;//Define the touch module interface
int val;// Digital variables "val"
void setup()
{
pinMode(Led,OUTPUT);// Define the LED for the output interface
pinMode(touch,INPUT);/*Define the touch module for the input interface*/
}
void loop()
{
val=digitalRead(touch);/* Will the value of the digital interface 3 read assigned to val*/
if(val==HIGH)/* When the key switch sensor detection signal, LED light*/
{
digitalWrite(Led,HIGH);
}
else
{
digitalWrite(Led,LOW);
}
}
136
Lesson 26 3 color - full color LED Module
This is RGB 3 color LED module for Arduino red green blue
Material: PCB
RGB signal output
3 color: Red, green, blue
Compatible with Arduino DIY project
Components
- 1 * USB cable
- 1 * RGB module
137
- Jumper wires
- 1 * Breadboard
三、Arduino test code：

int redpin = 11; //select the pin for the red LED
int bluepin =10; // select the pin for the blue LED
int greenpin =9;// select the pin for the green LED
int val;
void setup() {
pinMode(redpin, OUTPUT);
pinMode(bluepin, OUTPUT);
pinMode(greenpin, OUTPUT);
Serial.begin(9600);
}
void loop()
{
for(val=255; val>0; val--)
{
analogWrite(11, val);
analogWrite(10, 255-val);
delay(1);
}
for(val=0; val<255; val++)
{
analogWrite(11, val);
delay(1);
}
Serial.println(val, DEC);
138

Kuman K1Arduino KIT Tutorials

Uploaded by

Copyright:

Available Formats

Kuman K1Arduino KIT Tutorials

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Kuman K1Arduino KIT Tutorials

Uploaded by

Copyright:

Available Formats

Http://www.kumantech.

Kuman K1 Super Starter Kit

Lesson0 lnstalling IDE

Click on the "Download"

Click the arrow pointing,

Click next, driver installation is complete.

Then look at "device manager".

Boards and Ports：

Lesson1 Add Libraries

What are Libraries?

How to Install a Library

Using the Library Manager

or like this (on Mac and Linux):

Finally, the staus will change to 'Done'.

If you encounter this, go back to Lesson 0 and check your installation.

The first line of code is:

int led = 13;

// initialize the digital pin as an output. pinMode(led, OUTPUT);

immediately start again.

(1) x 5mm red LED

(1) x 220 ohm resistor

(1) x 1k ohm resistor

(1) x 10k ohm resistor

(2) x M-M wires

Firstly, the positive lead is longer.

But first, more about resistors...

- 1 * kuman Uno board

- 1 * Resistor (10k Ohm)

The schematic diagram：

Step2: Compile the code

Step 3: Upload the sketch to the KUMAN Uno board

//Controlling Led By Button

Lesson 5 Fire alarm test

- 1 * kuman Uno board

- 1 * Mini bread plate

- 1 * UNO extension plate

int flame=A5;//Define flame interface

val void setup()

Lesson6 8x8 dot matrix experiment

1.8*8 dot matrix diagram

2.8*8 dot matrix physical map

3. 8*8 dot matrix scanning mode

Connection diagram of this experiment.

- 1 * KUMAN Uno board

Lit 8X8 dot matrix LED a LED as follows：

void displayNum(byte rowNum,int colNum)

Lesson7 Active Buzzer module

Arduino buzzer module

Below test is use Analog to control buzzer frequency.

value = analogRead(potPin);Read the value of the resistor pin

When the button is pressed the speaker can make a sound.

const int buttonPin = 4; // Push pin;

Below is use PWM to control buzzer:

Lesson8 Passive buzzer

The difference between an active buzzer and a passive buzzer:

In this experiment, we use an active buzzer.

Step 1: Build the circuit

The schematic diagram:

Bread board 1 bread board jumper 1 tie