RaspberryPi:ProgrammingInPython - Revision history

CRNKEE002: /* Using Threads */

2020-10-28T06:03:38Z

Using Threads

156.155.132.175: /* The RPI.GPIO Library */

2020-09-23T17:23:08Z

The RPI.GPIO Library

CRNKEE002: /* Timed Thread Usage */

2020-09-22T12:00:42Z

Timed Thread Usage

CRNKEE002: /* I2C */

2020-09-11T09:34:06Z

I2C

CRNKEE002: /* Basic IO */

2020-09-10T10:07:02Z

Basic IO

CRNKEE002: /* The RPI.GPIO Library */

2020-09-10T09:59:29Z

The RPI.GPIO Library

CRNKEE002 at 18:25, 6 February 2020

2020-02-06T18:25:54Z

CRNKEE002: /* I2C */

2020-02-06T10:29:54Z

I2C

CRNKEE002 at 07:56, 6 February 2020

2020-02-06T07:56:24Z

CRNKEE002 at 07:54, 6 February 2020

2020-02-06T07:54:52Z

@@ Line 257: / Line 257: @@
 For example, if you want to create a separate thread to fetch a sensor value five times, you could do it as follows:
-<pre>import threading
+<syntaxhighlight lang="python" line='line'>import threading
 import time
 import RPi.GPIO as GPIO
@@ Line 269: / Line 269: @@
          time.sleep(2)
-if __name__ == &quot;__main__&quot;:
+if __name__ == "__main__":
      setup()
-     # Create a thread to call the function and pass &quot;12&quot; in as sensor pin
+     # Create a thread to call the function and pass "12" in as sensor pin
      x = threading.Thread(target=fetch_sensor_vals, args=(12,))
-     print(&quot;Starting thread&quot;)
+     print("Starting thread")
      x.start()
-     print(&quot;Waiting for the thread to finish&quot;)
+     print("Waiting for the thread to finish")
      x.join()
-     print(&quot;Reading finished&quot;)</pre>
+     print("Reading finished")
 == Timed Thread Usage ==

@@ Line 14: / Line 14: @@
 It is included in the environment variables by default, so to use it, you can simply just import it into your Python script:
-<syntaxhighlight lang="python">include RPi.GPIO as GPIO</syntaxhighlight>
+<syntaxhighlight lang="python">import RPi.GPIO as GPIO</syntaxhighlight>
 You need to specify which board mode you’re using. For more information on board modes, see Section [[RaspberryPi:Overview#GPIO_Pins]]. Board modes are specified as follows:

@@ Line 282: / Line 282: @@
 Often in embedded systems we want a specific task to run every X time units. There is an option in the Python threading library. It works as follows:
-<pre>import threading
+<syntaxhighlight lang="python" line='line'>import threading
 import datetime
-&quot;&quot;&quot;
+def print_time_thread():
-This function prints the time to the screen every five seconds
+    """
-&quot;&quot;&quot;
+    This function prints the time to the screen every five seconds
-def print_time():
+    """
-     YOUR = threading.Timer(5.0, print_time)
+     thread = threading.Timer(5.0, print_time_thread)
-     YOUR.daemon = True
+     thread.daemon = True  # Daemon threads exit when the program does
-     YOUR.start()
+     thread.start()
      print(datetime.datetime.now())
-if __name__ == &quot;__main__&quot;:
+if __name__ == "__main__":
-     print_time() # call it once to start the thread
+     print_time_thread() # call it once to start the thread
      # Tell our program to run indefinitely
      while True:
-         pass</pre>
+         pass
 You will see that in this code example, we have also set the <code>daemon</code> flag of the thread to be be <code>True</code>. A daemon thread will shut down immediately when the program exits. In essence, the daemon thread will run indefinitely in the background until your application exits, and you do not need to worry about calling <code>join()</code>.<ref>It’s important to note that calling t.join() will wait for a thread to finish executing, even if it is a daemon.
 </ref>

← Older revision		Revision as of 09:34, 11 September 2020
Line 154:		Line 154:

	<code>smbus</code> has multiple methods. The documentation for these is quite minimal, but brief descriptions are available [http://wiki.erazor-zone.de/wiki:linux:python:smbus:doc here].		<code>smbus</code> has multiple methods. The documentation for these is quite minimal, but brief descriptions are available [http://wiki.erazor-zone.de/wiki:linux:python:smbus:doc here].
		+
		+	Note: If you're working with EEPROM (specifically 24C32), you may need to read the answer to the questions given [https://www.raspberrypi.org/forums/viewtopic.php?p=1401819&sid=582cace49dad59d93f4e0369047dd89d#p1401819 here].

	== SPI ==		== SPI ==

@@ Line 45: / Line 45: @@
 Digital output on the Raspberry Pi is accomplished by writing values to channels. A channel is a pin, which is numbered in the way you’ve configured. Basic configuration of a pin for output is as follows:
-<pre>GPIO.output(&lt;channel&gt;, &lt;Logic&gt;)</pre>
+<syntaxhighlight lang="python">GPIO.output(<channel>, <Logic>)</syntaxhighlight>
 Your logic (high, 3.3V, or low, 0V), can be specified as follows:
 <ul>
 <li><p>For 3.3V (high) output:</p>
-<pre>
+<syntaxhighlight lang="python">
-GPIO.output(&lt;channel&gt;, GPIO.HIGH)
+GPIO.output(<channel>, GPIO.HIGH)
-GPIO.output(&lt;channel&gt;, 1)
+GPIO.output(<channel>, 1)
-GPIO.output(&lt;channel&gt;, True)
+GPIO.output(<channel>, True)
-</pre></li>
+</syntaxhighlight></li>
 <li><p>For 0V (low) output:</p>
-<pre>
+<syntaxhighlight lang="python">
-GPIO.output(&lt;channel&gt;, GPIO.LOW)
+GPIO.output(<channel>, GPIO.LOW)
-GPIO.output(&lt;channel&gt;, 0)
+GPIO.output(<channel>, 0)
-GPIO.output(&lt;channel&gt;, False)
+GPIO.output(<channel>, False)
-</pre></li></ul>
+</syntaxhighlight></li></ul>
 Channels can also be specified in lists, for example:
-<pre>LEDs = (11,12)
+<syntaxhighlight lang="python">LEDs = (11,12)
 GPIO.output(LEDs, GPIO.HIGH) # Will turn all channels HIGH
-GPIO.output(LEDs, (GPIO.HIGH, GPIO.LOW)) # Will the first channel HIGH, and the second LOW</pre>
+GPIO.output(LEDs, (GPIO.HIGH, GPIO.LOW)) # Will the first channel HIGH, and the second LOW</syntaxhighlight>
 Note that you can also read the state of the pin/channel that is set as an output by using the <code>input()</code> function. For example, if you wanted to toggle pin 12, you could do something as follows:
-<pre>GPIO.output(12, not GPIO.input(12))</pre>
+<syntaxhighlight lang="python">GPIO.output(12, not GPIO.input(12))</syntaxhighlight>
 == Analog ==
@@ Line 82: / Line 83: @@
 To read the value of a digital pin, you can use the <code>input()</code> function:
-<pre>if GPIO.input(12):
+<syntaxhighlight lang="python">if GPIO.input(12):
-     print(&quot;Pin 12 HIGH&quot;)
+     print("Pin 12 HIGH")
 else:
-     print(&quot;Pin 12 LOW&quot;)</pre>
+     print("Pin 12 LOW")</syntaxhighlight>
 === Pull Up/Pull Down Resistors ===
 Using pull up and pull down resistors is essential when working with digital logic. Thankfully, the Raspberry Pi has internal pull up and pull down resistors. To make use of these, initialize the pin/channel as follows:
-<pre>GPIO.setup(&lt;channel&gt;, GPIO.IN, pull_up_down=GPIO.PUD_UP)
+<syntaxhighlight lang="python">GPIO.setup(<channel>, GPIO.IN, pull_up_down=GPIO.PUD_UP)
 # or
-GPIO.setup(&lt;channel&gt;, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)</pre>
+GPIO.setup(<channel>, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)</syntaxhighlight>
 === Interrupts ===
 Very often it is useful to set up an interrupt, for example to trigger an event when a button is pressed. Callback functions are executed on a different thread. If you have multiple callbacks, know that they will be executed sequentially as only one thread exists for interrupts. Interrupts can be implemented as follows:
-<pre># The bounce time is given in milliseconds.
+<syntaxhighlight lang="python"># The bounce time is given in milliseconds.
 # If your pin is set to use pull down resistors
-# Connect a button between &lt;channel&gt; and 3.3V
+# Connect a button between <channel> and 3.3V
-GPIO.add_event_detect(&lt;channel&gt;, GPIO.RISING, callback=callback_method(), bouncetime=200)
+GPIO.add_event_detect(<channel>, GPIO.RISING, callback=callback_method(), bouncetime=200)
 # If your pin is set to use pull up resistors
-# Connect a button between &lt;channel&gt; and GND
+# Connect a button between <channel> and GND
-GPIO.add_event_detect(&lt;channel&gt;, GPIO.FALLING, callback=callback_method(), bouncetime=200)  </pre>
+GPIO.add_event_detect(<channel>, GPIO.FALLING, callback=callback_method(), bouncetime=200)  </syntaxhighlight>
 === Other functions ===
 The RPi.GPIO Library offers other functions for interrupts the first is the <code>wait_for_edge()</code> function, which is designed to block execution until an edge is detected. You can detect edges of <code>GPIO.RISING</code>, <code>GPIO.FALLING</code>, or <code>GPIO.BOTH</code>. The timeout is given in milliseconds:
-<pre># wait for up to 5 seconds for a rising edge
+<syntaxhighlight lang="python"># wait for up to 5 seconds for a rising edge
-edge = GPIO.wait_for_edge(&lt;channel&gt;, GPIO_RISING, timeout=5000)
+edge = GPIO.wait_for_edge(<channel>, GPIO_RISING, timeout=5000)
 if edge is None:
      print('Timeout occurred')
 else:
-     print('Edge detected on pin ', TO)</pre>
+     print('Edge detected on pin <CHANNEL>')</syntaxhighlight>
 Another function is the <code>event_detected()</code> function. From the docs: “The event_detected() function is designed to be used in a loop with other things, but unlike polling it is not going to miss the change in state of an input while the CPU is busy working on other things. This could be useful when using something like Pygame or PyQt where there is a main loop listening and responding to GUI events in a timely basis.”
-<pre>GPIO.add_event_detect(channel, GPIO.RISING)  # add rising edge detection on a channel
+<syntaxhighlight lang="python">GPIO.add_event_detect(channel, GPIO.RISING)  # add rising edge detection on a channel
 if GPIO.event_detected(channel):
-     print('Button pressed')</pre>
+     print('Button pressed')</syntaxhighlight>
 = Communication Protocols =

@@ Line 14: / Line 14: @@
 It is included in the environment variables by default, so to use it, you can simply just import it into your Python script:
-<pre>include RPi.GPIO as GPIO</pre>
+<syntaxhighlight lang="python">include RPi.GPIO as GPIO</syntaxhighlight>
-You need to specify which board mode you’re using. For more information on board modes, see Section [sec:BoardModes]. Board modes are specified as follows:
+You need to specify which board mode you’re using. For more information on board modes, see Section [[RaspberryPi:Overview#GPIO_Pins]]. Board modes are specified as follows:
-<pre>GPIO.setmode(GPIO.BOARD)
+<syntaxhighlight lang="python">GPIO.setmode(GPIO.BOARD)
 # or
-GPIO.setmode(GPIO.BCM)</pre>
+GPIO.setmode(GPIO.BCM)</syntaxhighlight>
 You also need to perform “cleanup” on GPIOs when your application exists. By performing cleanup and resetting all pins to their default modes, you can prevent possible damage to your Raspberry Pi. The cleanup function is called as follows:
-<pre>GPIO.cleanup()</pre>
+<syntaxhighlight lang="python">GPIO.cleanup()</syntaxhighlight>
 If your program is meant to run indefinitely, and only close upon an exception, you can wrap it in a try catch, as follows:
-<pre>if __name__ == &quot;__main__&quot;:
+<syntaxhighlight lang="python">if __name__ == "__main__":
      # Make sure the GPIO is stopped correctly
      try:
@@ Line 31: / Line 31: @@
              main()
      except KeyboardInterrupt:
-         print(&quot;Exiting gracefully&quot;)
+         print("Exiting gracefully")
          GPIO.cleanup()
      except e:
-         print(&quot;Some other error occurred: {}&quot;.format(e.message)})
+         print("Some other error occurred: {}".format(e.message)})
-         GPIO.cleanup()</pre>
+         GPIO.cleanup()</syntaxhighlight>
 = Basic IO =

@@ Line 7: / Line 7: @@
 This chapter serves as a short guide for programming in Python on the RPi. You will also find some templates for techniques such as debouncing, or making use of the Raspberry Pi’s multicore architecture by implementing threading.
-== The RPI.GPIO Library ==
+= The RPI.GPIO Library =
 The RPi.GPIO library is the common Python library used on the Raspberry Pi. Documentation for the library can be found here:<br />
@@ Line 36: / Line 36: @@
          print(&quot;Some other error occurred: {}&quot;.format(e.message)})
          GPIO.cleanup()</pre>
-== Basic IO ==
+= Basic IO =
 Read the documentation, available [https://sourceforge.net/p/raspberry-gpio-python/wiki/Outputs/ here].
-=== Digital Logic ===
+== Digital Logic ==
 Digital output on the Raspberry Pi is accomplished by writing values to channels. A channel is a pin, which is numbered in the way you’ve configured. Basic configuration of a pin for output is as follows:
@@ Line 71: / Line 71: @@
 <pre>GPIO.output(12, not GPIO.input(12))</pre>
-=== Analog ===
+== Analog ==
 The Raspberry Pi does not have any analog input pins. You will need to use something like the [https://cdn-shop.adafruit.com/datasheets/MCP3008.pdf MCP3008] to read analog voltages.
-=== Inputs ===
+== Inputs ==
-==== Digital Read ====
+=== Digital Read ===
 To read the value of a digital pin, you can use the <code>input()</code> function:
@@ Line 85: / Line 85: @@
 else:
      print(&quot;Pin 12 LOW&quot;)</pre>
-==== Pull Up/Pull Down Resistors ====
+=== Pull Up/Pull Down Resistors ===
 Using pull up and pull down resistors is essential when working with digital logic. Thankfully, the Raspberry Pi has internal pull up and pull down resistors. To make use of these, initialize the pin/channel as follows:
@@ Line 92: / Line 92: @@
 # or
 GPIO.setup(&lt;channel&gt;, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)</pre>
-==== Interrupts ====
+=== Interrupts ===
 Very often it is useful to set up an interrupt, for example to trigger an event when a button is pressed. Callback functions are executed on a different thread. If you have multiple callbacks, know that they will be executed sequentially as only one thread exists for interrupts. Interrupts can be implemented as follows:
@@ Line 103: / Line 103: @@
 # Connect a button between &lt;channel&gt; and GND
 GPIO.add_event_detect(&lt;channel&gt;, GPIO.FALLING, callback=callback_method(), bouncetime=200)  </pre>
-==== Other functions ====
+=== Other functions ===
 The RPi.GPIO Library offers other functions for interrupts the first is the <code>wait_for_edge()</code> function, which is designed to block execution until an edge is detected. You can detect edges of <code>GPIO.RISING</code>, <code>GPIO.FALLING</code>, or <code>GPIO.BOTH</code>. The timeout is given in milliseconds:
@@ Line 120: / Line 120: @@
      print('Button pressed')</pre>
-== Communication Protocols ==
+= Communication Protocols =
 The RPi.GPIO library has no native support for communication protocols. Very often, specific Python libraries are provided on a per-device use case. However, this can become tedious and cause your code to become bloated. See the sections below for relevant libraries for using I2C and SPI directly.
-=== I2C ===
+== I2C ==
 Ensure you enable I2C in <code>raspi-config</code>.
@@ Line 149: / Line 149: @@
 <pre>i2cdevice.write_byte_data(address, &lt;register&gt;, &lt;value&gt;)</pre>
-==== Methods Available ====
+=== Methods Available ===
 <code>smbus</code> has multiple methods. The documentation for these is quite minimal, but brief descriptions are available [http://wiki.erazor-zone.de/wiki:linux:python:smbus:doc here].
-=== SPI ===
+== SPI ==
 Ensure you enable SPI in <code>raspi-config</code>.
@@ Line 178: / Line 178: @@
 # Close the SPI connection
 close()</pre>
-==== Settings ====
+=== Settings ===
 The following settings are configurable in the <code>spidev</code> library, and can be set as follows:
@@ Line 199: / Line 199: @@
 SI/SO signals shared
-==== Methods ====
+=== Methods ===
 The following methods are available in the <code>spidev</code> library
@@ Line 231: / Line 231: @@
 </ul>
-== Using Threads ==
+= Using Threads =
 [https://realpython.com/intro-to-python-threading/ This guide] serves as the basis for the text below. This manual does not teach everything there is to know about threading in Python, but will give you the basics to be able to utilize threads for simple tasks that may be of use to you in the practicals. It’s strongly recommended you read through that text if you have not yet been exposed to threading concepts.
@@ Line 237: / Line 237: @@
 This text does not cover issues and precautions when working with threads, such as mutex’s and locks, data races, producer/consumer concerns and the likes. However, these are knowledge areas of critical importance, and it is strongly suggested that the reader tries to make an effort to understand these concerns before writing threaded code.
-=== The Threading Library ===
+== The Threading Library ==
 The Python library <code>threading</code> library offers all the functionality one would expect. Import it in to your code in the standard way:
@@ Line 249: / Line 249: @@
 # “Shut it down” by joining
-=== Basic Thread Usage ===
+== Basic Thread Usage ==
 For example, if you want to create a separate thread to fetch a sensor value five times, you could do it as follows:
@@ Line 274: / Line 274: @@
      x.join()
      print(&quot;Reading finished&quot;)</pre>
-=== Timed Thread Usage ===
+== Timed Thread Usage ==
 Often in embedded systems we want a specific task to run every X time units. There is an option in the Python threading library. It works as follows:

@@ Line 136: / Line 136: @@
 Once you connect a device, you can run <code>$gpio i2cdetect</code> to determine if a device is detected on the I2C bus. In the example below, there is an electronic compass (GY-271) connected to the Pi.
-[[File:Figures/i2cdetect|frame|none|alt=|caption An i2cdetect example<span data-label="fig:i2cdetect"></span>]]
+[[File:I2cdetect.png|frame|none|alt=|An i2cdetect example]]
 To initialize an I2C device, do the following:

@@ Line 1: / Line 1: @@
 [[Category:RaspberryPi]]
 = Overview =
 Most of the content in the guide comes from the documentation, available online [https://sourceforge.net/p/raspberry-gpio-python/wiki/Home/ here].
-Python, while not as powerful as C or C++, is quickly becoming a common choice for embedded systems developers due to its ease of use and rapid development times. See [https://spectrum.ieee.org/at-work/innovation/the-2018-top-programming-languages this IEEE article].
+Python, while not as powerful as C or C++, is quickly becoming a common choice for embedded systems developers due to its ease of use and rapid development times. See [https://spectrum.ieee.org/at-work/innovation/the-2018-top-programming-languages this IEEE article]. For information on programming in C or C++, go to [[RaspberryPi:ProgrammingInC]].
 This chapter serves as a short guide for programming in Python on the RPi. You will also find some templates for techniques such as debouncing, or making use of the Raspberry Pi’s multicore architecture by implementing threading.

← Older revision		Revision as of 07:54, 6 February 2020
Line 302:		Line 302:
	You will see that in this code example, we have also set the <code>daemon</code> flag of the thread to be be <code>True</code>. A daemon thread will shut down immediately when the program exits. In essence, the daemon thread will run indefinitely in the background until your application exits, and you do not need to worry about calling <code>join()</code>.<ref>It’s important to note that calling t.join() will wait for a thread to finish executing, even if it is a daemon.		You will see that in this code example, we have also set the <code>daemon</code> flag of the thread to be be <code>True</code>. A daemon thread will shut down immediately when the program exits. In essence, the daemon thread will run indefinitely in the background until your application exits, and you do not need to worry about calling <code>join()</code>.<ref>It’s important to note that calling t.join() will wait for a thread to finish executing, even if it is a daemon.
	</ref>		</ref>
−
−	~~= Programming in C/C++ =~~