1

PH-315 Portland State University

MICROCONTROLLERS BASIC INPUTS and OUTPUTS (I/O)

Bret Comnes, Jianghua Bai

ABSTRACT A microcontroller is an integrated circuit containing a processor and programmable

read-only memory,1 which is widely used as an interface between hardware and software systems. We will use the Arduino microcontroller. “Arduino is a tool for making computers that can sense and control more of the physical world than your desktop computer. It’s an open-source physical computing platform based on a simple microcontroller board, and a development environment for writing software for the board.”2 This laboratory session pursues obtaining familiarity with the Arduino microcontroller operation, namely installation of communication with your computer, downloading the proper software and programming code, and gaining familiarity with the Arduino boards to implement basic I/O tasks.

1. INTRODUCTION About the board.

Microcontrollers are small computers designed to do real time controls. A microcontroller is essentially a small programmable computer contained on a single integrated circuit, consisting of a processor, read-only memory (ROM) used to store the program instructions, and a set of input and output pins which can be used to interact with an external circuit.

The microcontroller IC is a digital device and, since the processor operates on “transistor to transistor” logic (TTL), only two logic states are acceptable: HIGH (~ +5 V) and LOW (~ 0 V). The microcontrollers come in all shapes, sizes, and layouts. Usually, they are quite small and use less power than traditional computers. Microcontrollers are often deployed in ‘appliances’ and serve an unmodifiable dedicated purpose, such as keeping track of what spin cycle your washing machine is on, or how much time is left before it should turn off your microwave oven. Make no mistake, microcontrollers are general purpose computers.

A major difference between a microcontroller and traditional computers is that they come with an array of analog and digital inputs and outputs. These inputs and outputs can be used to read environmental data from sensors, talk to other computers or devices and electronically control other systems, which provide environmental outputs such as a LCD screens, mechanical switches or servo motors, etc.

Getting started with microcontrollers can be a tedious process, as they can require a number of supporting circuits, USB controllers, programmers, boot-loaders and power supplies just to load your first program onto the microcontroller chip. Often times you will

2

start with a prototyping board that puts all of the necessary components in a convenient and ready to use package.

Arduino Microcontroller and its advantages This lab will be using the single board Arduino Leonardo Microcontroller.3 It is similar to

the Arduino Uno,4 with the major difference being that the latter uses Surface Mount Technology (SMT)5 instead of the older “thru-hole” 6 technology. The Arduino drastically lowers the difficulty of getting started with a microcontroller (compared to plain ATMEGA/PIC/ARM chips), as it provides all the necessary tools for making the microcontroller do interesting things, which would be daunting if staring with just a plain microcontroller chip.

The Arduino is based around an 8-bit Atmel AVR microcontroller, and has supporting systems like a boot loader for uploading programs, a USB controller, as well as a barrel jack for external power. It is programmed using a language that is based off of C++. It uses an integrated development environment (IDE) for writing, compiling and uploading

your programs to the board.

Figure 1. The Arduino Leonardo Microcontroller.2

2. GETTING STARTED. How to talk to the board This lab is based off of the Arduino software, which can be downloaded for free from the

3

Arduino website. 7 Unlike other embedded systems development environments Arduino software is quick to download and set up, and has zero cost associated with the software, which makes it a convenient to work with when the primary goal is to come up with a working prototype quickly and cheaply. There is a large community of Arduino users and there exists a massive pool of example programs and libraries compared to other educational prototyping boards.

Whatever you do, DO NOT APPLY MORE THAN 5V TO ANY PIN ON THE ARDUINO. Otherwise it will damage or destroy the microcontroller board. Also, avoid using the Arduino to power directly devices that draw high current. Instead opt for a separate power source and an NPN transistor, or something similar.

Find a Computer You are free to use one of the classroom computers or your own laptop. Plug your Arduino into the computer using the micro USB cable. Please be careful with the delicate connectors.

A. Download and Launch the Arduino Software Download the latest Arduino Integrated Development Environment (IDE)7 available at

the following site, http://arduino.cc/en/Main/Software

The downloading process may take a few minutes.

Then go to the “downloads” folder in your computer (typically located in the “favorites” section). Identify with your mouse the Arduino application file, and enter a left-click.

After a few minutes, the monitor screen should pop-up the following message: “Do you want to allow this program making change in your computer?” Proceed accordingly.

(You may be prompted to add hardware if you are on windows. If it asks for a driver, tell the windows driver wizard to look inside a folder called drivers inside the Arduino folder. If the computer you are using already has the Arduino software downloaded, look inside that folder usually found in Program Files, or wherever you copied it, or the shortcut on the desktop leads too.)

B. Selecting the Board The Arduino application software is now installed in your computer. It should be available

from the Start menu (lower left corner) of your computer

Click on the Arduino application to launch the Arduino Integrated Development Environment (IDE).

It is time now to tell the Arduino IDE what particular Arduino board we will be using (i.e. to tell the IDE what hardware it will be compiling). For that purpose, once the IDE is open, navigate to the toolbar and select the Leonardo board,

Toolbar → Tools → Board → Arduino Leonardo

4

If you are using a different board, select the one you have from this list instead.

This step may vary from system to system.

NOTE: For Mac computers, it may be necessary to move the Arduino.exe program into the apps folder for it to run properly.

C. Selecting a Serial Port This step varies from system to system. This step is to tell the computer which serial port the Arduino chip can be reached at, for both programing the board as well as talking to it during runtime.

Figure 2: Port selection in Windows and OS X.

C.1 Windows

Select Toolbar → Tools → Serial Port → COM5

where COM5 is the serial port that has been assigned to your Arduino by windows. (The computer may have assigned another port number to your Arduino, like COM4, for example; check it out). You may have more than one port in the list. To know which port is associated with the Arduino, you can check the list with the Arduino unplugged, and check it again with it plugged in. The extra port that appears in the list is the Arduino’s port.

C.2 OS X

5

Usually the Arduino is the first item in the Serial Port list. Another way to tell is that it has tty in the name and does not have the world ‘bluetooth’ in it.

NOTE: Sometimes, even if the port selection has been set through the Arduino program

(as described above), the actual selection may not happen. It may be necessary then to specify the serial port though the following sequence: Left-click the “Start” button; right click on “Computer”, select “Properties” >> Left-click on “Device Manager” >> “Ports”

If you had Windows 10 operating system: Right click on the windows icon (bottom –left corner of your screen >> Device Manager >> Universal Serial Bus Controller

3. PROGRAMMING the ARDUINO A. Compiling and uploading your first program. Example program: The “Blink” program

We have chosen the “blink” program available in the Arduino library. For that purpose, navigate to, Toolbar → File → Examples → 01. Basics → Blink The program shown in Fig. 5 will appear in your screen. We proceed next to verify that it compiles, and then to upload it to your microcontroller board.

A.1 Compiling your program lets the compiler check the program for syntax and structure errors. Press the verify button (the one displaying a “check out” mark), located at the top-left side of the screen (see Fig. 3). It will take a few minutes to compile the sketch and then to return the ‘Done compiling’ message (see Figure 3). If you get an error, something went wrong.

Fig 3. Left: The “Verify” and “ Upload” buttons. Right: Successful-compile message. A.2 Once the compiling process is completed, go ahead and upload the program to the

micro-controller board by pressing the upload button (located right next to the verify button). This process should provide a similar completion message after a few seconds. The LEDs

6

on the Arduino will blink during the upload, but should settle down after a few seconds. Your program is now on the Arduino and running in a loop sequence. Once the program you uploaded is running, the tiny LED labeled ‘L’ on your Arduino should be slowly blinking in response to the uploaded “Blink” program. The LED labeled ‘L’ is wired to Pin 13 on the Arduino; this is a digital pin with a resistor built in so that an LED can be connected directly between that pin and ground. Go ahead and connect an LED between Pin 13 and GND. It should blink at the same rate as the ‘L’ LED on the board. Congratulations! You now have a working Arduino that is talking to the Arduino IDE.

B. Actual code

Arduino is based off Processing,8,9 an open source programming language that has some similarities to C. However much of the language has been simplified from C. In this section, we will go over the basics of the language, look at some simple examples of code, and even write some of our own.

Figure 4 shows the bare minimum code you need for an Arduino program.

1 void setup() 2 // put your setup code here, to run once: 3 4 void loop() 5 // put your main code here, to run repeatedly: 6 ______________________________________________________________________ Fig. 4 The minimum amount of code for an Arduino Program.

There are two parts to this minimum program, the void setup() section, and the void loop() section.

When your program runs, it starts executing your code line by line, starting with the void setup() section; your program will execute any code that is inside the brackets, .

Next, it will start executing the code inside the void loop() , until it gets to the end of the available instructions, at which point, the program starts back over at the beginning of void loop() , retaining any variables or settings from prior lines of code.

Let’s look at a simple example that you should already have pulled up, the Blink program, which is found in Figure 5.

C. UNDERSTANDING the Blink Program __________________________________________________________________________________________

7

1 /*

2 Blink

3 Turns on an LED on for one second, then off for one second, repeatedly. 4

5 This example code is in the public domain.

6 */

7 // Pin 13 has an LED connected on most Arduino boards.

8 // Let’s give it a name, “led” for example:

9 // Variables have to be declared at the beginning of the program, outside either loop

10 int led = 13; 11

12 // the setup routine runs once when you press reset:

13 void setup()

14 // initialize the digital pin as an output.

15 pinMode(led, OUTPUT);

16 17

18 // the loop routine runs over and over again forever.

19 void loop()

20 digitalWrite(led, HIGH); // turn the LED on (HIGH is the voltage level)

21 delay(1000); // wait for a second

22 digitalWrite(led, LOW); // turn the LED off by making the voltage LOW

23 delay(2000); // wait for two seconds

24 __________________________________________________________________________________________

Figure 5: The Blink Program in all its glory.

C.1 Comments If a block of text is wrapped inside the symbols, /* */ (such as lines 1 thru 6 in Figure 5), or if a command line has the symbol, // in front of it (such as line 12), it means that the content is a comment.

Comments are little notes you leave in your code. They are not executed or interpreted by your program in any way. It is good practice to add comments to your code. They can help

8

you think about your program, and will also remind you, and others that see your code, what the program does or how it works.

Running down lines 1-9, we see a block of comments describing the function of the program, how it works, as well as the license. The first piece of code we see is on line 10.

C.2 Variables int led = 13; First, notice that this code is not inside the void setup() nor the void loop(). That is because it is a variable and variables have to be declared at the beginning of our program, outside either loop.

Variables are incredibly useful tools. Variables store information that can be used later in the program as many times as you need. They can be updated during run-time and can be used to store values temporarily for repeated use.

Any variable we decide to use has to be declared at the beginning of the program. That is, variables are declared before your void setup() or void loop() sections.

Line 10 declares a variable named led; it also declares it as an integer variable int; and then assigns the number 13 to that variable. This variable is used to reference the physical pin that we will be using in our program. It is used as an abstraction layer, so that if we ever go back and change which pin we want to use, we can update all the places in our program that reference this pin number simply by updating the initial variable value.

The basic syntax of a variable declaration is: Type variable_name = value;

Example: int led = 13;

The available variable types can be found on the Arduino website.10 Please reference that list if you want to use values other than integers.

C.3 Pin Modes The next piece of code in our program is void setup(). Stepping inside the curly braces of this structure, we come to the following line:

pinMode(led, OUTPUT);

Each pin on the Arduino has a name assigned to it. The name is printed next to the corresponding pin on the microcontroller board (Figure 1).

There are two primary types of pins: Digital and Analog. Digital pins simply have a number for a name, and analog pins have the letter A followed by a number for a name.

C.3.1 Defining digital pins as output/input

9

Digital pins can be either inputs or outputs Digital pins can either read or write digital signals (0 or 5V). Before you do either, you must tell your program what you will be using the digital pin for. The command pinMode( led, OUTPUT); tells our program that the pin associated with the led variable will be a digital output. The general command to define the pin type is as follows: pinMode( [PIN-NUMBER], [PIN-TYPE]);

Example to define the digital-pin “led” as an output: pinMode( led, OUTPUT);

C.3.2 PWM digital signals Some digital pins can also output pulse-width-modulation (PWM) signals, which are square signals with different duty cycle). This is a way to produce a similar effect (when the pin is used to drive the illumination of an LED, for example) of an analog voltage. Digital pins with PWM capability have a tilt-symbol ˜ printed next to their name on the board.

Digital mode pins produce outputs at either the high or low digital voltage level as expected. However, many external circuit components may require analog average voltage values. PWM is one way to produce output digital voltages whose net effect is similar to analog voltages in the range of 0 – 5 V. This is accomplished by outputting a periodic pulse signal, but with variable duration of the high and low voltage levels.

When looking at the RMS value of this periodic signal of different duty cycle: i) Shortening the duration of the high-level (5V) will lower the RMS voltage (up to the point that when the HIGH pulse width is 0 seconds then its effect is that of a 0 V). ii) By increasing the duration of the high-level (5V) will raise the RMS voltage, (up to the point that when the LOW pulse width is 0 s, then the output is just 5 V). This has the net effect of simulating a continuous DC voltage range, using only digital voltages.

The pin value still must be assigned (via the microcontroller software) in discrete steps between 0 and 255, giving possible output voltages that differ by steps of,

∆V = 5V/ 255

(Recall the Arduino is based on an 8-bit Atmel AVR microcontroller; hence there are 28 = 256 values in base-2 available.)

More about “PWM output” later.

C.3.3 Analog pins Analog Pins can read in analog voltages between 0V and 5V,

The Arduino has inside a 10-bit analog-to-digital converter circuit (210 = 1024) that reads this voltage and converts it to a single 10-bit value (a number between 0 and

10

1023). Here 0 represents 0V, and 1024 represents 5 V. This 10-bit value is what the software sees as the input on that pin.

The discrete values of the input and output pins are a limitation of the microcontroller when working with external systems that expect continuous values, such as LED and photoresistors.

Analog pins do not need a pin mode set before reading within your program.

Available pin modes can be found at the Arduino website.11

C.4 Generating an output Once the pin mode is set, the program exit the void setup() and enters the void loop(), the part of the program that will run over and over in an infinite loop.

The first command to execute is,

digitalWrite( led, HIGH);

The command digitalWrite( [PIN], [VALUE] ) lets us set the output value of a digital pin that has been set to an OUTPUT type. In this case, we write a value of HIGH, or 5V, to the pin referred to by the led variable. A value of LOW would refer to 0V.

Next the program tells the Arduino to wait for a given period, before executing the next line of code. This period is equal to 1000 ms.

delay(1000);

After waiting for 1000 ms, the code writes a value of LOW to the led pin, and then makes it wait for 2000 ms.

digitalWrite( led, LOW);

delay(2000);

At this point, there is no more code left in our program, so it starts executing void loop() again. Congratulations, you now have some basic understanding of how an Arduino program is written.

4. MODIFYING the BLINK PROGRAM Now try at modifying the blink program. What we are going to do is define a new variable called wait, give it a value, and then replace the delay time on the Arduino with our new variable. 4.1 Create a new variable

Right below the led variable declaration, add a new variable named wait of type int and assign a reasonable value different than 1000 (like 100 for example). Add also a comment describing what this variable is used for.

4.2 Use your new variable

11

We want to use this new variable to declare the time we wait in between turning our LED on and off. Go ahead and replace the old delay values with your new variable name.

4.3 Verify and upload your modified program The Arduino should still be set up from when you first uploaded the first blink program. Verify your new program to see if it compiles. If you get an error, check your work for syntax error. Did you forget a semicolon or a brace? Once your program verifies, and you are able to upload it to your board, you should start to see your LED blink faster or slower, depending on the value you defined your variable.

_____________________________________________________________________________________ 1 int led = 13; 2 int wait = 100; // Time to wait before blinking 3 4 void setup() 5 pinMode(led, OUTPUT); 6 7

8 void loop() 9 digitalWrite(led, HIGH);

10 delay(wait); //Wait for the amount declared in the wait variable

11 digitalWrite(led, LOW);

12 delay(wait); //Wait for the amount declared in the wait variable 13

_________________________________________________________________________________________ Figure 6: The modified Blink Program.

5. USING INPUTS to CONTROL OUTPUTS 5.1 Understanding Pulse Width Modulation (PWM)

Arduino cannot output true analog signals. One way to output a digital signal that reflects the value of an analog signal is pulse-width-modulation (PWM) Compared to a square signal, where the duty cycle is 50% (i. e. half of the period HIGH and half of the period LOW), the PWM signal has a duty cycle in which the time during which the signal remains HIGH is proportional to the analog signal.

For example, when driving an LED with a PWM signal one is able to vary the brightness of the LED by writing on the PWM-pin a proper (digital) value: An analog signal should be first read by the Arduino (which converts it to a value between

0 and 1023). [The Arduino has inside a 10-bit analog-to-digital converter circuit (210 = 1024) that reads this voltage and converts it to a single 10-bit value (a number between 0 and 1023).]

That value has then to be converted into an 8 bit (0 to 255 range) number. [Its implementation is explained in section 5.2c below. See also line 12 in the program shown in Fig. 8].

12

The latter is used to write the PWM pin. The net result is the generation of a digital signals (switching on and off) that makes the photodiode emit power proportional to the duty cycle.

From the Arduino library Load the 01.Basic → Fade example program and upload it to your Arduino board.

Toolbar → File → Examples → 01. Basics → 0.1.Basic

(a modified version of the program is shown in Fig. 8 below). Wire up the LED to the pin that is used in the program; if it is a digital pin other than pin 13, you will need to add a 330 Ω resistor in series with the LED. If you increase the delay time to 80, you should be able to observe the PWM flicker at lower brightness levels. You can leave the LED in place. Observe how the signal looks like on your oscilloscope.

5.2 Controlling the PWM output with a potentiometer We will control the PWM signal (i.e. we will control the duty cycle of the square signal) by

reading the voltage from a potentiometer terminal connected to the analog input A0. Hook up a 10k potentiometer between the 5V and ground; connect the middle leg to the A0 analog input on your Arduino as seen in Figure 7. Modify the Fade program code to the one shown in Figure 8, so that a potentiometer controls the LED brightness. In the new program we have declared a few new variables to keep track of i) the analog input pin, ii) the variables used for storing values from our analog input readings, and iii) our PWM output values. See the comments in the code for more context.

13

PWM

GND

10 kΩ D9 D8

D10

A0 A1

LED

330 Ω

Analog input

PWM

5V

Figure 7 Potentiometer and LED wired up to the Arduino. Pin 9 is a PWM output.

5.2.a Establishing serial communication In the void setup() loop we use Serial.begin(9600); to begin serial communications, at 9600 bits of data per second, between the Arduino and the computer (remember how we picked a serial port in Section 2C above). Outputting data to the serial line is a nice way to see (on the computer screen) what is going on in your code while it is running. But remember that your program will run no faster than the speed of your serial line.

5.2b Reading the analog signal from the potentiometer The next new piece of code is analogRead(pot); It reads the analog input (0-5V range) on pin pot

(in the program this pin has been declared as pin A0)

and converts it to a discrete value between 0 and 1023 (210 discrete values range.) (Recall the Arduino has inside an analog-to-digital converter circuit that reads this voltage and converts it to a number between 0 and 1023).

14

5.2c Controlling the PMW Pin led (declared as pin 9 in the program) only outputs PWM values (i.e. square wave with different duty cycles). First, we have to solve the following issue:

On one hand, the PWM can be controlled only by an 8 bit digital number (that is, one needs to write a value between 0 and 255 to the led pin). On the other hand, in our current experiment we have a number between 0 and 1023 read from the analog pin pot. We need to make a corresponding conversion then.

One alternative is to use the command called map() which handles the analog-input-range to the PWM-output-range conversion. Its syntax is,

map (valuetoscale, fromLow, fromHigh, toLow, toHigh)

In our program we use, outputValue = map(sensorValue, 0, 1023, 0, 255); /* Map sensorValue to 8 bits (0 to 255) */

See the map info page for more details.12

Next we write the adjusted input value to our led pin using, analogWrite( led, outputValue); outputValue controls the duty cycle of the PWM

1 const int led = 9; // the PWM pin where the LED is attached to 2 const int pot = A0; // A0 will be the analog input channel

3 int sensorValue = 0; // sensorValue will store the value read from the pot

4 int outputValue = 0; // outputvalue will be the (duty cycle) value to be

5 // sent to the PWM pin

6 void setup() 7 pinMode(led, OUTPUT); // Declare the PWM pin 9 to be an output

8 Serial.begin(9600); // Open a serial monitor at 9600 baud 9

10 void loop()

11 sensorValue = analogRead(pot); // store pot value in sensorValue 12 outputValue = map(sensorValue, 0, 1023, 0, 255); // map sensorValue to // a 8 bit number (0 to 255) 13 analogWrite(led, outputValue); // write the analog out value to pin led

15

14 // outputValue specifies the “duty cycle”

15 Serial.print("sensor = " ); // print the results to the serial monitor 16 Serial.print(sensorValue); 17 Serial.print("\t output = "); // Check the role of the \t character. See what // happens if deleted 18 Serial.println(outputValue); 19

20 delay(2); // wait 2 milliseconds for daq to settle 21 ___________________________________________________________________________________________________________________________________

Figure 8. Program to control the LED with a potentiometer.

5.2.d Displaying the input and output voltages Finally we print these input and output values the serial line using the command, Serial.print(outputValue); Open the serial monitor now to view these values in real time. Go to Tools→ Serial Monitor You should see the input and output values similar to Figure 9.

Figure 9. The serial monitor in action. 5.3 Photo Resistor

16

Remove the potentiometer and wire in a photo-resistor as seen in Figure 10. A photo-resistor has a variable resistance depending on how much light is incident on it. Using the same code as in Section 5.2, observe the output of the photo resistor and the PWM output on pin 9 simultaneously on your oscilloscope. Vary the amount of light incident on the photo-resistor and observe and compare the PWM output and analog voltage across the photo-resistor. Check also what happens, upon light incident on the photoresistor, when you interchange the position of the photoresistor with the 10 kΩ resistor in the circuit. If there is any difference, explain why.

10 kΩ Photoresistor

330 Ω LED

GND 5V

A0

PWM

D9

Figure 10. Photo-resistor connected to the analog input A0. At the time of preparing your reports feel free to modify the circuit drawing (Fig. 11 offers some symbols ready for copy and paste). Feel free also to improve the programs.

Figure 11. Symbols that may be helpful when designing your circuits. (To modify them, just copy and paste them into the “PAINT” application.

6. INPUTS and OUTPUTS: “Positive logic” and “negative logic” programming

17

Here we show professional and non-professional ways to establish inputs and outputs.

Digital Output A digital output typically constitutes a “control” signal. Digital Input Typically, digital inputs are signals coming from a sensor; hence, they are also referred

to as “measurement” signals. Comments on good and bad measurements Digital circuits are noisy! In Fig. 12 above, when a port is left floating (hanging wire) one

cannot predict the value at the output port. The state of pin D7 can be low or high, easily influenced by the environments.

In section 6.1 below we will see that when the input port is connected either by a pull up resistor to 5V, or by a pull down resistor to GND then the output will be more predictable because the circuit has a more deterministic input. One can be sure the signal is due to input actions, not due to the noise!

Figure 12. NO RECOMMENDED circuit to demonstrate digital inputs. Do not

leave an input terminal (used in your program) connected to a hanging wire.

6.1 Recommended procedures to establish a digital input (for more critical applications) (In the circuits of Figs. 13 and 15 only the inputs setups are good, not the outputs).

When a circuit requires logic 1 to operate, engineers may refer to this condition as positive logic. Thus, a positive voltage causes the action to take place. On the other hand, if a circuit requires a logic 0 to cause action, this type circuit is referred to as negative logic.13

6.1A Positive-logic input connection “The input is effective when the set to HIGH” or “The input circuit requires a logic 1 to cause action.” Connect the circuit shown in Fig. 13. Use the positive logic program given in Fig. 14. One at a time, connect digital pin D7 to 5V, float (wire left hanging), and GND. Compare the different results.

18

Figure 13. RECOMMENDED connection for implementing a positive-logic input.

(The MCU uses the program given in Fig. 14.) void setup() // put your setup code here, to run once: pinMode(7,INPUT); pinMode(4,OUTPUT);

void loop() // put your main code here, to run repeatedly: if (digitalRead(7)==HIGH) digitalWrite(4,HIGH); // if the input is HIGH // the output is HIGH else digitalWrite(4,LOW); // modify here! for your own measurement . delay(2);

Figure 14. Example of a positive logic program. 6.1B Negative-logic input connection “Input is LOW effective” or “the input circuit requires a logic 0 to cause action.” Connect the circuit shown in Fig. 15. Use the negative logic program shown in Fig. 16. (It is

called “negative logic input” because the input causes the desired effect when connected to a LOW state).

1 kΩ

19

Figure 15. RECOMMENDED connection for implementing a negative-logic input

(The MCU uses the program given in Fig. 16.) One at a time, connect digital 7 to: 5V, float (wire left hanging), GND. Compare the different results.

void setup()

// put your setup code here, to run once: pinMode(7,INPUT);

pinMode(4,OUTPUT);

void loop()

// put your main code here, to run repeatedly:

if (digitalRead(7)==LOW) digitalWrite(4,HIGH); else digitalWrite(4,LOW);

// modify here! for your own measure.

delay(2);

Figure 16. Negative logic program.

It turns out, there is some consensus that negative logic implementation has advantages over positive logic. [The advantages of the program in Fig. 16 is not directly transparent. The advantages are actually in the hardware layer and signal level layer, not in the program. Technically, all programs are treated "equally" by the processor. So whether positive or negative programing is better can only be decided at the hardware.]

1 kΩ

300 Ω

20

6.2 procedures to establish a digital output. Objective: to light up a bulb 6.2A Positive-logic output connection to light up a bulb. A digital output typically constitutes a “control” signal. In Fig. 17 the LED lights-up when the output D4 is HIGH. This connection is OK for non-critical applications.

Figure 17. Circuit no recommended but OK for non-critical applications. (The MCU uses the program given in Fig. 14, a positive logic program). Pay attention to the implementation of the output signal. When driving devices of high impedance (hence low current flows) this is OK. But if you want to drive high power devices this configuration is not ideal; the microcontroller board will not be able to drive high levels of current.

6.2B Negative-logic output connection to light up the LED. (Recommended) In Fig. 18 the MCU uses a program that makes the bulb to light-up when the output D4 is LOW. This strategy allows driving both low and high power bulbs. (It is OK to drive high currents to GND.)

Figure 18. Connection for implementing a negative-logic output.

6.3 Microcontroller configured to function as a digital voltmeter Use a potentiometer to provide a 0 to 5V analog input.

300 Ω

21

You will be able to measure a voltage less than 5V, and display the readings on the serial port. Input the signal to the A5, and check the result from your monitor. Use a DMM to check your result.

void setup() // put your setup code here, to run once: pinMode(A5,INPUT); Serial.begin(9600); void loop() int j; j=analogRead(A5); float k; k=(float)j*5/1023; Serial.println(k); // modify here! for your own measure. delay(1000);

Figure 19.

6.4. Build a counter to measure a sensor signal 6.4A Build the circuit shown in Fig. 20, and upload the program shown in Fig. 21. Cover the photo resistor with your hands, or shine the photo resistor with your cellphone

flash. Check the readings from your monitor. If the counter does not work, you may need to adjust a parameter value inside the program

(see comment inside the program). What is physically going on when you change that parameter? What is the reason that a proper value of that parameter makes the counter to work?

Figure 20.

22

6.4B After you find the threshold of your measurement from section 6.4A, use the counter to measure how many times you swing your hand over the sensor. (This program contains software implementation of latch, flip-flop and counters, which are sequential logic. The details of sequential logics will be covered after the combinational logic labs. )

// This program demonstrate a digital flip-flop // and a digital counter!

void setup() pinMode(A5,INPUT); Serial.begin(9600);

int s=0; // Variable to monitor the counting

void loop() int j; j=analogRead(A5); if ( j< 349 ) // Change this number so your counter responds // to the events (your hand blocking the sensor). delay(3); if (analogRead(A5)>350) Serial.println(++s); Figure 21. Counter of number of times the user blocks a photodiode.

References

1 A ROM associates a specific output binary number with each input binary number according to its fixed internal logic. The fixed relationship between input and output distinguishes the ROM from other memory circuits.

2 Arduino.cc. Introduction. http://arduino.cc/en/Guide/Introduction, 2013. 3 Arduino.cc. Arduino leonardo. http://arduino.cc/en/Main/ArduinoBoardLeonardo, 2013. 4 Arduino.cc. Arduino uno. http://arduino.cc/en/Main/ArduinoBoardUno, 2013. 5 Wikipedia. Surface-mount technology. http://en.wikipedia.org/wiki/Surface-mount_technology,

2013. 6 Wikipedia. Through-hole technology. http://en.wikipedia.org/wiki/Through-hole_technology, 2013. 7 https://www.arduino.cc/en/Main/Software 8 Processing programming language. http://processing.org/, 2013. 9 http://hello.processing.org/editor/

23

10 Arduino.cc. Reference page. http://arduino.cc/en/Reference/HomePage, 2013. 11 Arduino.cc. Pinmode(). http://arduino.cc/en/Reference/PinMode, 2013. 12 Arduino.cc. map(). http://arduino.cc/en/Reference/Map, 2013. 13 http://www.sealevel.com/support/article/AA-00509/0/What-is-the-difference-between-positive-

and-negative-logic-in-digital-I-O-circuits.html