Categories
ARM ARM ARCHITECTURE ARM PROGRAMMING COMPUTER HARDWARE ELECTRONICS EMBEDDED EMBEDDED COMPUTERS EMBEDDED PROGRAMMING HARDWARE PROGRAMMING PYTHON RASPBERRY PI RASPBERRY PI PROJECTS TUTORIALS

Blinking An LED Connected To GPIO Pin Of Raspberry Pi Using Python

Introduction

If you are just getting started with Raspberry Pi, connecting a simple LED to one of the GPIO pins of a Raspberry Pi and controlling it using software program that you write will give you a very good grasp of how a computer hardware and its program works internally. You will realize how you can control various aspects of a computer hardware using software, how a computer works at the bit level, how to write Python programs to control hardware and more.

In summary, working on getting an led connected to a GPIO pin of your Raspberry Pi will help you in understanding the fundamentals of a computer architecture and computer science in general.

Raspberry Pi 3B

What You Will Learn From This Project?

Connecting an LED to the GPIO pins of a Raspberry Pi to control it is a simple Beginner Raspberry Pi Project that lets you learn more about:

  • Raspberry Pi hardware internals
  • General Purpose Input/Output (GPIO) pins of a Raspberry Pi
  • Raspberry Pi Register Set
  • Ohm’s Law
  • Python Programming
  • Python Library – Raspberry Pi GPIO library
  • The working of an Light Emitting Diode (LED)

What Hardware Is Required To Set Up A Blinking LED Project?

This a very simple, beginner friendly Raspberry Pi project that can be set up by anyone with minimal hardware or software knowledge. The hardware components required to set up this blinking LED project is also quite minimal. You need the following hardware components available with you to get it going:

  • Raspberry Pi Module
  • Solderless Breadboard
  • Keyboard
  • Monitor
  • Raspberry Pi Power Supply
  • SD Card with working Raspbian OS
  • Jumper wires for rigging up the circuit
  • LED
  • Resistor (1K Ohm)
  • Multimeter

Theory Behind How The Raspberry Pi Blinking LED Project Work

When you look at the Raspberry Pi board, you will see a bunch of pins protruding out. Among these, there is a row of 40 pins located on one side of the board as shown in the image below.

If you look closely enough in the above image, you will notice the label “GPIO” written right under it. These pins are called the GPIO pins or General Purpose Input Output pins. What the name GPIO implies is that these pins do not have any fixed functionality within the board and hence can be used for general purposes. It means that we can connect our LED into one of these pins and can turn it ON or OFF using these pins. But how?

How to control the Raspberry Pi GPIO pins programmatically?

Raspberry Pi 3 board runs on Broadcom’s ARM CPU chipset BCM2837. Among many other things, this processor chipset has a built in GPIO controller aka General Purpose Input Output controller. The 40 GPIO pins header shown in figure 1 is connected to 40 controllable pins of the GPIO controller. Now, we can control each of these pins individually by programming the appropriate registers inside this GPIO controller.

To understand how to program each of these pins using GPIO controller, we need to look into the Technical Reference Manual or datasheet of the Broadcom ARM chipset BCM2837.

In the BCM2837 SOC (System On Chip aka CPU) datasheet linked above, if we jump into page 89 we come across a dedicated chapter talking about General Purpose Input Output (GPIO). If we go through this chapter, we can learn about all the GPIO registers available and figure out the GPIO registers we need to program to turn ON or OFF the LED we are going to connect to the Raspberry Pi 3 GPIO pins.

As the name implies, GPIO pins can be configured as either an Input pin or an Output pin. When we configure a GPIO pin as an input pin, we are sending data bit (either 0 or 1) into the Raspberry Pi BCM2837 SOC i.e. data signal is sent from outside the board to inside the board (hence the name input). On the other hand, if we configure the Raspberry Pi GPIO pin as an output pin, the board will send the data bit signal (either 0 or 1) from inside the board to the outer world where any device connected to it will receive this signal.

So, if we want to control an LED that is connected to one of the Raspberry Pi’s GPIO pin, we need to configure that pin as a GPIO OUT pin (aka output pin) so that we can send an electrical signal from the Raspberry Pi board to the external LED connected to this pin.

The configuration of a GPIO pin to be an INPUT or OUTPUT pin is controlled by programming the GPIO Controller Register called GPIO Function Select Register (GPFSELn) where n is the pin number.

So for example, if we choose to use the GPIO8 pin to control the LED, i.e. we connect our LED to GPIO 8 pin, we need to program the GPFSEL register for the GPIO 8 pin and configure it as an Output pin. When we check the datasheet at page 91 and 92, we notice that GPIO pin is configured by setting the bits 26 to 24 in the GPFSEL register (that is field name FSEL8). And from the datasheet, we also find that to set the pin as an output pin, we need to set its value as 001 i.e. bit 26 is set to 0, bit 25 is set to 0 and bit 24 is set to 1.

So, if we can somehow set these values in the GPFSEL register using a programming language such as Python, we will be able to start controlling the LED connect to this pin!

If this is all overwhelming to you, do not worry. We will not have to scratch our head a lot for now as we can simply make use of Raspberry Pi’s GPIO Python library that helps us in making most of this work for us. But I just wanted to explain to you as to what this GPIO Python library is doing under the hood.

How To Connect An LED To Raspberry Pi GPIO?

Designing The Circuit

In order to connect an LED to GPIO pin 8 of Raspberry Pi, we need to first design and understand how the circuit is going to work.

Can we connect an LED directly to a Raspberry Pi GPIO pin without a resistor?

The answer is No. Raspberry Pi provides 3.3 Volts of power on its GPIO output pin according to Raspberry Pi datasheet specification. However, if we take a look at a standard LED, we notice that it normally operates at a much lower voltage. If we look at an LED specification, we notice that a typical LED usually operates at just 1.7 Volts and draws 20 mA. So, if we need to connect this LED to the GPIO pin of our Raspberry Pi, we need to bring down the voltage delivered by the pin to our LED to operate at or under 1.7V. How to do that? We connect a resistor in series with our LED so that the 3.3 Volts GPIO output of Raspberry Pi gets split between the resistor and our LED. By choosing a right value of the resistor such that it consumes 1.6 Voltage, we can ensure that LED finally gets only 1.7 Volts.

Calculating the resistor value to connect with LED and Raspberry Pi GPIO

In order to calculate the value of resistor that we should be using, we make use of the Ohm’s Law.

Ohm’s Law is defined using the equation:

V = I/R where V is the voltage, I is the current and R is the resistor value.

So, if we want to have V=1.6 Volts consumed by our resistor so that the current coming from GPIO pin is at I=20 mA, we need to connect a resistor whose value is:

1.6 = (20 mA)/R

or R = 80 Ohms (or approx 100 Ohms)

So, we choose a resistor of value 100 Ohms connected in series with our resistor to ensure that we only get 1.7 Volts and 20 mA of current, the optimum operating values as required by our LED.

A 100 Ohm resistor is identified by the color bands: Brown, Black & Brown.

Hook up the led through 100 Ohm resistor to GPIO 8 pin of Raspberry Pi as shown in the figure below:

Note that when you are hooking up the LED, the terminal pin that is longer is positive. Once you have connected as shown in the figure, it is now time to program the Raspberry Pi GPIO controller to start controlling the LED to turn ON or OFF.

We will be using Python to program our Raspberry Pi GPIO controller. Now, the simplest way to program this is by making use of the Python GPIO library.

To install the Python Raspberry Pi GPIO module, open up your linux terminal and type the following command.

sudo apt-get install python-rpi.gpio python3-rpi.gpio

Now the above command will install the required Python GPIO library module onto our Linux development machine. Once successfully installed, It is now time to start programming the Raspberry Pi GPIO controller.

We will be toggling our GPIO pins at 1 second intervals such that our LED will turn ON and OFF forever until the Python program we write will be terminated i.e., we will be running the code to perform infinite loop of toggling the GPIO 8 pin ON and OFF.

Create a new file on your computer by typing the following command in the terminal:

touch blinky.py

This should create our new program file called blinky.py

Open up this file using nano editor by typing the following command in the terminal:

nano blinky.py

Now that the file is opened, it is time to start writing our program to control the GPIO Pin 8 using Python GPIO library module.

First thing first, we will import the Python GPIO library module using command:

import RPi.GPIO as GPIO

Next, we will import python time library to perform 1 sec sleep operation between each GPIO toggle

from time import sleep

Next, we need to configure our GPIO library to use our GPIO physical pin numbering as seen on the Raspberry Pi board physically:

GPIO.setmode(GPIO.BOARD)

This ensures that when we say GPIO pin 8 in the program, it actually maps to the GPIO Pin 8 seen on the Raspberry Pi board.

Next, configure GPIO pin 8 to be a GPIO Out pin and set its initial output value to be low:

GPIO.setup(8, GPIO.OUT, initial=GPIO.LOW)

Finally we will start an infinite loop in Python such that we turn ON the GPIO 8 (by setting it HIGH) or turn it OFF (by setting it LOW) after every 1 second delay. This is achieved using the program below:

while True: # Infinite loop
    GPIO.output(8, GPIO.HIGH) # Turn GPIO 8 pin on
    sleep(1)                  # Delay for 1 second
    GPIO.output(8, GPIO.LOW)  # Turn GPIO 8 pin off
    sleep(1)                  # Delay for 1 second

That’s it, this should be all the program that we need to type in our blinky.py file and run it using the command:

python3 blinky.py

This should start turning your LED ON and OFF every second!

Here is the full code for your reference:

import RPi.GPIO as GPIO
from time import sleep

GPIO.setmode(GPIO.BOARD)
GPIO.setup(8, GPIO.OUT, initial=GPIO.LOW)

while True: # Infinite loop
    GPIO.output(8, GPIO.HIGH) # Turn GPIO 8 pin on
    sleep(1)                  # Delay for 1 second
    GPIO.output(8, GPIO.LOW)  # Turn GPIO 8 pin off
    sleep(1)                  # Delay for 1 second

This should conclude our tutorial on how to get a simple LED connected to a General Purpose Input/Output (GPIO) pin turning ON and OFF using a Python program that makes use of Python Raspberry Pi GPIO library. There can be many variants to this such as using other GPIO pins, connecting more than one LEDs to multiple GPIO pins and controlling them all in different ways to display interesting patterns on the LEDs. If we are even more curious, we can also figure out a way to control the BUILT-IN LEDs that are already present on our Raspberry Pi boards to bypass their current usage and be used for by own programs for our purposes.

We will dwell into these and many other interesting ways to make use of our Raspberry Pis to understand and learn more about the computer hardware, its architecture and much more in our future articles.

Categories
Android Filesystem HARDWARE SMARTPHONES TUTORIALS

What Is Jmtpfs In Linux & How To Use It? Explained

Jmtpfs is a combination of FUSE (Userspace Filesystem) and MTP (Media Transfer Protocol) stack integrated together to form a filesystem tool. The jmtpfs tool is then used to mount your smartphones or other handheld devices onto your Linux computer so that you can browse the content of your smartphone or handheld device directly from your computer.

Jmtpfs filesystem stack in a Linux computer

What Is A FUSE Filesystem?

FUSE filesystem stands for Userspace Filesystem. In general cases, when you need to create your own filesystems, you need to have knowledge of the Operating System (OS) kernel and block storage device drivers. This would restrict the development of new filesystems to only kernel developers.

In Linux, in order to overcome this, a new type of filesystem model was introduced called the FUSE file system. In a FUSE filesystem, you will make use of a pre-written generic FUSE Linux kernel module, which you as a userspace developer need not have to modify. In addition to this, you will also make use of a pre-written FUSE userspace library that would provide the required API interfaces to the FUSE kernel modules form the userspace.

Using these two modules, it is now possible for the userspace developers to write their own filesystems by inserting the FUSE kernel module into their machine’s operating system and then writing their own filesystem with the help of FUSE library modules.

Such developed FUSE filesystems will place the files and directories exposed by the filesystem in the userspace region of the OS which is accessible by even non privileged users.

What Is Media Transfer Protocol (MTP)?

Media Transfer Protocol (MTP) is a type of protocol used to transfer media files such as audio files, videos files or image files at the file level rather than at the storage level. This protocol became a USB standard to transfer media files between a computer and a USB device.

The main reason why we would use an MTP protocol instead of the USB standard Mass Storage protocol is that when you use a Media Transfer Protocol (MTP) to transfer file, the whole file is transferred from the device to the computer or vice versa. So, the entire transfer of file happens as a single unit, hence transactional. In this way, both the device and host can continue to access the same file simultaneously, which is not possible when using a USB Mass Storage Device Class (MSC) protocol.

In case of an USB MSC protocol, when a USB mass storage device such as a music player is mounted on to a computer, the music player loses control over the files which is stored within itself and is taken over by the host computer’s filesystem. In this situation, the host computer can modify the content of the files and the USB device has no way to prevent it. This may lead to host computer corrupting the files of the USB mass storage device! But this situation is not at all possible when we use an MTP protocol due to its transactional file transfer nature. Hence MTP protocol is preferred over a USB MSC protocol.

JMPTFS tool makes use of both FUSE filesystem and the USB MTP protocol to mount the content of your smartphone onto a local directory on your computer, thereby giving access to the file contents of your smartphone even when you are a non privileged user.

How To Use Jmtpfs tool To Transfer Files From Your Smartphone

In order to use jmtpfs, you first need to create a local directory such as ‘myPhone’ in your computer. Next, you connect your Android or any other smartphone to your computer using an USB cable. Then by issuing the console command ‘jmtpfs myPhone’ you can mount the content of your smartphone onto your mount directory ‘myPhone’. In other words, after issuing the command, you will be able to browse the content of your smartphone within the mount directory ‘myPhone’ just like any other files and folders of your computer.

> mkdir ~/myPhone
> jmtpfs ~/myPhone
> ls myPhone
  Internal storage/

At the end, in order to unmount your smartphone filesystem from your computer, you need to issue another command:

> fusermount -u ~/myPhone

This should unmount your smartphone’s filesystem safely without corrupting any part of the filesystem on your smartphone.

Categories
HARDWARE TUTORIALS

What Is USB Type C? Explained In Simple Terms

USB Type C aka USB-C is a new type of USB connector that is getting popular these days in both smartphones and laptops for their high transfer speeds and easy connectivity (You can connect it in any direction you want and it will still work!). In this article, we will try to explain to you what a USB Type C connector and cable is and why everyone are moving to them.

USB-C is a set of new form of USB connectors that comes in two forms namely:

USB Type C Receptacle

USB Type C Receptacle

and

USB Type C Plug

USB Type C Plug

Usually, the USB-C Receptacles are found in devices such as laptops while USB-C Plugs are found in smartphones. We will then use a USB Type C cable to connect our smartphone to the laptop.

Why do we need to use a USB-C over micro-USB?

A USB device such as a USB mouse, USB keyboard, USB Pen drives etc all talk to our computers or smartphones using a special language called USB protocol. This USB protocol is designed by an organization called USB Implementers Forum or USB IF for short.

The USB protocol has been evolving over the years and its latest protocol was designed and revealed by USB IF recently. This new protocol called USB 3.0 has increased the speed at which data gets transferred between the computer and USB devices (like smartphones, USB stick) from 480 Mbps in the earlier USB 2.0 specification to 5 Gbps in USB 3.0 specification! This is a huge increase in speed of data transfer between the devices and hence using USB 3.0 was a major upgrade over USB 2.0

USB Type-C is a new type of USB connector that was released almost at the same time as when the new USB 3.0 specification was released. So almost all the USB device manufacturers who wanted to use USB 3.0 specification also adopted USB Type-C connector instead of the usual micro USB connectors used with USB 2.0

Hence, USB-C connector has recently become synonymous to USB 3.0, although you will still be able to find devices with USB-C connector still following USB 2.0 specification.

This has also given raise to a myriad of problems and confusions in terms of choosing the appropriate USB 3.0 cables which we will address and explain how to identify them in the future articles.

How exactly is USB 3.0 connector different from micro USB connector?

A simple micro USB connector which we have all been using all these years simply had 5 pins within itself where two pins were used to power the device (Vcc, Gnd), two more pins where used to transfer the data (D+ and D-) and a final pin was used to detect the device type (Mode Detect).

However, in case of a USB Type-C connector, we have 24 pins in total, each of which had a unique role to play in the data exchange and charging of devices. So in simple terms, USB Type-C connector increased the pin numbers within each connector from 5 pins earlier in micro USB to 24 pins now in USB Type-C connector!

In the upcoming articles, we will go in detail to understand how USB 3.0 protocol works with the new USB-C or USB Type-C connector and how it achieves the extra-ordinary speed of 5 Gbps data transfers, but for now, this should give you enough idea on the USB-C connector type and its difference from the earlier micro USB connector.