Skip to main content
Engineering LibreTexts

7.1: Introduction

  • Page ID
    25718
  • \( \newcommand{\vecs}[1]{\overset { \scriptstyle \rightharpoonup} {\mathbf{#1}} } \) \( \newcommand{\vecd}[1]{\overset{-\!-\!\rightharpoonup}{\vphantom{a}\smash {#1}}} \)\(\newcommand{\id}{\mathrm{id}}\) \( \newcommand{\Span}{\mathrm{span}}\) \( \newcommand{\kernel}{\mathrm{null}\,}\) \( \newcommand{\range}{\mathrm{range}\,}\) \( \newcommand{\RealPart}{\mathrm{Re}}\) \( \newcommand{\ImaginaryPart}{\mathrm{Im}}\) \( \newcommand{\Argument}{\mathrm{Arg}}\) \( \newcommand{\norm}[1]{\| #1 \|}\) \( \newcommand{\inner}[2]{\langle #1, #2 \rangle}\) \( \newcommand{\Span}{\mathrm{span}}\) \(\newcommand{\id}{\mathrm{id}}\) \( \newcommand{\Span}{\mathrm{span}}\) \( \newcommand{\kernel}{\mathrm{null}\,}\) \( \newcommand{\range}{\mathrm{range}\,}\) \( \newcommand{\RealPart}{\mathrm{Re}}\) \( \newcommand{\ImaginaryPart}{\mathrm{Im}}\) \( \newcommand{\Argument}{\mathrm{Arg}}\) \( \newcommand{\norm}[1]{\| #1 \|}\) \( \newcommand{\inner}[2]{\langle #1, #2 \rangle}\) \( \newcommand{\Span}{\mathrm{span}}\)\(\newcommand{\AA}{\unicode[.8,0]{x212B}}\)

    In this exercise we shall examine basic digital output using both the Arduino code libraries and more direct “bit twiddling”. The target of this effort will be controlling an LED, including appropriate driver circuits.

    First, let’s use a modified version of the example Blink program. This blinks the on board test LED connected to Arduino pin 13 at a rate of two seconds on, one second off. We will add serial text output to verify functionality.

    Type the following code into the editor:

    /*
          MyBlink
          Turns on an LED then off, repeatedly.
          With serial output
    */
    
    // Pin 13 has an LED connected on most Arduino boards. Give it a name:
    #define LEDPIN 13
    
    void setup()
    {
          // initialize the digital pin as an output.
          pinMode( LEDPIN, OUTPUT );   
          // initialize serial communication at 9600 bits per second:
          Serial.begin( 9600 );
    }
    
    void loop()
    {
          Serial.println("On");
          digitalWrite( LEDPIN, HIGH ); // turn the LED on
          delay(2000);                  // wait for 2 secs
    
          Serial.println("Off");
          digitalWrite( LEDPIN, LOW );  // turn the LED off
          delay(1000);                  // wait for 1 sec
    }
    

    Compile the code and transfer it to the board. Open the Serial Monitor. You should see messages on the Serial Monitor reflecting the state of the on-board LED.

    The code is more or less self-explanatory but a few details may be in order. First, pin 13 on the Arduino Uno’s digital header is connected to a small surface mount LED. The pin is connected to a current limiting resistor which is connected to the LED’s anode, the cathode of which returns to ground. Thus, a high voltage turns on the LED. The setup routine sets this pin for output and establishes the serial communication system. The loop routine uses digitalWrite() to alternately send this pin high or low, thus turning the LED on and off. The delay function is used to hold the levels for a moment so that they can be seen easily with the naked eye. The delay function works well enough here but it is a simple busy-wait loop meaning that no other useful work can be done by the controller during the delay time. This is a serious limitation for more intensive programming tasks but for now it is sufficient.

    Let’s move off of the internal LED to an external LED. While the AVR 328P can deliver in excess of 20 milliamps per pin, if we choose to drive several LEDs it may be better to use transistor drivers for them in order to reduce the current and power demands on the controller. The basic style follows:

    clipboard_e50814e83e127afb9b02c16cafa5a73b5.png

    Figure \(\PageIndex{1}\): NPN Driver

    clipboard_e26781fcbecdea64ce14af68e941f5dc2.png

    Figure \(\PageIndex{2}\): PNP Driver

    The NPN driver will saturate and turn on the LED with a high base voltage while the PNP version saturates with a low base voltage. In both cases the LED current is the saturation current which can be approximated as the supply voltage minus the LED voltage, divided by the collector resistance. For example, to achieve 10 milliamps with a 5 volt supply and a red LED (about 2 volts forward bias), the collector resistor would need to be about 300 ohms. The base resistor would be about twenty times this value resulting in a base current of about 700 microamps. This would guarantee saturation for any reasonable transistor beta. The 2N3904 or 2N3906 are common choices but if a large number of devices are to be driven it might be wise to consider a driver IC such as the ULN2003.

    Let’s modify the example above to use an external NPN driver on Arduino digital pin 8. For future reference, this corresponds to Port B, bit 0. First, wire up the driver on a protoboard using standard resistor values (a 330 and a 6.8k should do). Jump the Vcc connection to the +5V header pin on the Uno and jump the ground connection to the Uno’s GND header pin (both on the POWER side of the board). Wire the input logic connection (Vbb) to Arduino digital pin 8. Modify the code as follows:

    /*    External LED Blink   */
    
    #define LEDPIN 8
    
    void setup()
    {
    
          pinMode( LEDPIN, OUTPUT );   
    }
    
    void loop()
    {
          digitalWrite( LEDPIN, HIGH );
          delay(2000);                  // wait for 2 secs
    
          digitalWrite( LEDPIN, LOW );
          delay(1000);                  // wait for 1 sec
    }
    

    Compile the code, transfer it and run it. You should have a nice blinking LED. Note the timing. Build the PNP driver and connect it to pin 8 in place of the NPN version (do not disassemble the NPN driver, just unhook it from the controller). Do not change the code. You should notice a difference in the on/off timing. If don’t notice a change, reconnect the NPN and look again.

    Now let’s consider direct access to the hardware without using the Arduino libraries. There are two ways to do this; the first is by looking up the actual addresses for the hardware ports and registers and assigning pointer variables to them. The second method (somewhat easier) involves using the pre-defined variables for the ports and registers.

    The following is a variation of the blink program using direct port access via pointers. Note that the variables for the port and data direction registers are declared and then assigned hard numerical addresses. These would vary from processor to processor so the code is not portable. That’s not desirable; however, the process does illustrate precisely what is going on with the controller and does so with a reduction in resulting assembly code. Note the usage of LEDmask. Changing the value of this allows you to access different bits of that port. Also, note the use of the bitwise OR, AND and COMPLEMENT operators (|&~) to set the appropriate bit(s) in the registers.

    /* Direct Blink: Using direct bit fiddling via pointers */
    
    // This is Port B bit 0, Arduino digital output number 8
    
    #define LEDMASK 0x01
    
    void setup()
    {
          unsigned char *portDDRB; 
    
          portDDRB = (unsigned char *)0x24;
    
          // initialize the digital pin as an output.
          *portDDRB |= LEDMASK;
    }
    void loop()
    {
          unsigned char *portB;
    
          portB = (unsigned char *)0x25;
    
          // turn LED on
          *portB |= LEDMASK;
          delay(2000); 
    
          // turn LED off
          *portB &= (~LEDMASK);
          delay(1000); 
    }
    

    Type in the code above and connect the NPN driver to pin 8. Compile and transfer the code, and test it. It should run as before.

    A better version of Direct Blink uses pre-defined variables such as PORTB. These can be defined within a header file and as such, can be adjusted across devices. This makes the code portable across a family of controllers rather than tied to a specific unit. As you might notice, the code also tends to be somewhat easier to read.

    /* Direct Blink 2: Using direct bit fiddling via pre-defined variables */
    
    // This is Port B bit 0, Arduino digital output number 8
    
    #define LEDMASK 0x01
    
    void setup()
    {
          // initialize the digital pin as an output.
          DDRB |= LEDMASK;
    }
    
    void loop()
    {
          // turn LED on
          PORTB |= LEDMASK;
          delay(2000);
    
          // turn LED off
          PORTB &= (~LEDMASK);
          delay(1000);
    }
    

    Type in the code above, compile and transfer the code, and test it. It should run as before.

    All versions of this program can be extended to control several output bits, each connected to something different. For example, one bit could control an LED while another bit controls a relay or power transistor that controls a motor. Using Direct Blink 2, multiple bits can be controlled with a single operation simply by creating an appropriate bit mask. For a quick example, simply set LEDMASK to 0x21 in Direct Blink 2 to control both the external and on-board LEDs in tandem. The limitation with this approach is that each item cannot be controlled with completely different timing; all items generally will have the same timing. It is possible to break up the delay calls into smaller chunks and insert calls to turn on and off individual bits between them. This is a rather clunky method though and is neither particularly accurate nor flexible if a great many items need to be controlled. We shall examine ways around this in future work.


    This page titled 7.1: Introduction is shared under a CC BY-NC-SA 4.0 license and was authored, remixed, and/or curated by James M. Fiore via source content that was edited to the style and standards of the LibreTexts platform; a detailed edit history is available upon request.