71. A Raspberry Pi Security Camera System

78,000 page views!!
I came across motionPie [this has now become motionEYE OS] some time ago and bookmarked it for later reference.  I only remembered it recently and looked into it in detail.  I discovered a fantastic system which is what I've been looking for for ages.

I've done live video via SSH HERE which was interesting, and even did control of LEDs via wireless network HERE but I hadn't realised that access to web pages on the internet is not possible unless you open a port on your router.  This is called Port Forwarding, and I've always been afraid to get involved in this by meddling with my router's settings in case I messed the whole thing up.

Anyway, this time I bit the bullet and had a go, and it worked!!  What I now have is an extremely cheap security camera system - with 2 cameras - and I can broadcast the live video images to the internet!

Camera 1 is the RasPi Camera at 1600 x 1200 pixels.  Camera 2 is the Logitech USB camera at 640 x 480 pixels.

The instructions for installing motionPie are very clearly given HERE by Gus of PI My LifeUP.  He also gives instructions for setting your router up for Port Forwarding HERE.  [The download page for motionEYE OS can be found HERE]. However, while the instructions give all the essential information, his router is not the same as my BT Infinity Hub 3.0 router.  So I went to my Home Hub web page and the information there is also useful, although after setting it up, you don't know whether your port is open or not.

However, I then found a useful site HERE which will confirm that your port is open and is not being blocked by the firewall.  There are of course other good sites with Port Forwarding testers.
Another program useful for showing you what devices are on your network is Zenmap available from HERE. Run it with a target of 192.168.1.0/24 and a command of nmap -sn 192.168.1.0/24.  This will list all the addresses of connected devices (hosts).

motionEye requires a dedicated SD card image on the Pi, because it is a stand-alone operating system (OS), but this is not a problem.  Once set up, you don't even need a monitor attached to the Pi, your motionEye console gives you access to everything you need, including downloading images to your PC and deleting images from the Pi.

The two cameras I am using are the RasPi Camera board, connected to the Pi through the CSI - camera serial interface - in the usual way, and a cheap USB camera I used to use for Skyping from my PC.  PI My LifeUP suggests that you can have even more USB cameras.  I will have to test that.

Here is an image of the control console [the motionEye console is almost identical, with some improvements]:

The available control options are too numerous to capture in one picture, but the image shows the main sections which open up and give almost total control of your video, stills, time lapse or motion activated images from all your cameras.

There's only one problem that I've noticed after running this for a couple of days  - my router port has for some reason closed a couple of times (it changed its IP address once too - maybe is this what is meant by Dynamic DNS - Dynamic Domain Name System?).  When this happens, you no longer have the ability to re-boot the Pi through the motionEye console.  If the Pi were to be placed somewhere remote, you would have to go to it and de-power and re-power it to get the system running again.  This is just something to bear in mind.

I have added a couple of time-lapse sequences (conveniently produced by motionPie/motionEye) below:

Camera 1:

Camera 2:

Here's a photo of the Pi with the RasPi Camera looking through my 8X zoom Telephoto lens.  You can see the cable running up to the USB camera which is looking through the window higher up.

Have a close look at this picture and see if you notice that pesky Jay bird nosing about.

Here he is pinching the tits' lunch:

Nice bird - a type of crow, and related to the magpie - apparently not that common in this part of the world - except my garden!  They are said to be "shy woodland birds" - this one's anything but shy.  I must report him to the RSPB!

motionEye is a really super piece of software.

70. The 4-digit 7-segment LED Display Revisited

46,000 page views!!
In a previous post (see HERE) I used an Arduino to drive a 4-digit, 7-segment LED display to count down from 9999 seconds to zero.  Just a few days ago, Alex Eames of RasPi.TV blogged (see HERE) to say that he managed to drive one of these displays with a Raspberry Pi and make it into a real-time clock.  In fact, he also offered a kit of parts to carry this out, so I bought one (only £12 including postage).  Here's the kit:

I thought this was interesting because other real time clocks I have built, have had a small circuit board powered by a separate button battery to keep the clock going even when the main board is switched off.  (See HERE.)  I wondered how you could do this even with a Raspberry Pi as, like the Arduino, it doesn't have a built in clock either.

The secret is that the Raspberry Pi is on-line and the Python language's time library is capable of reading the time at regular intervals from the internet, using the time.ctime() function.  This had been previously reported just about a year ago by bertwert (see HERE).

The details of Alex's kit can be found in his blog, referenced above, so I'll not repeat them here.

Common Cathode

Here is the kit assembled and connected to my Raspi B+:

Note that the Pi has a WiFi dongle and is connected to my wireless network.  You can see the LED Display unit mounted on the mini-breadboard, and the 8x 100 Ω resistors, all supplied by Alex.

Here's a video:

PB193845 from Vimeo.

And here's my version of Alex's code which was derived from that of  bertwert:

	# 4-digit 7-segment COMMON CATHODE display driven by Raspberry Pi B+
	# code modified, tweaked and tailored from code by bertwert
	# on RPi forum thread topic 91796
	# and fiddled with a bit more by S&S
	import RPi.GPIO as GPIO
	import time
	GPIO.setmode(GPIO.BCM)
	# GPIO ports for the 7seg pins
	segments = (11,4,23,8,7,10,18,25)
	# 7seg_segment_pins (11,7,4,2,1,10,5,3) + 100R inline
	for segment in segments:
	GPIO.setup(segment, GPIO.OUT)
	GPIO.output(segment, 0)
	# GPIO ports for the digit 0-3 pins
	digits = (22,27,17,24)
	# 7seg_digit_pins (12,9,8,6) digits 0-3 respectively
	for digit in digits:
	GPIO.setup(digit, GPIO.OUT)
	GPIO.output(digit, 1)
	num = {' ':(0,0,0,0,0,0,0),
	'0':(1,1,1,1,1,1,0),
	'1':(0,1,1,0,0,0,0),
	'2':(1,1,0,1,1,0,1),
	'3':(1,1,1,1,0,0,1),
	'4':(0,1,1,0,0,1,1),
	'5':(1,0,1,1,0,1,1),
	'6':(1,0,1,1,1,1,1),
	'7':(1,1,1,0,0,0,0),
	'8':(1,1,1,1,1,1,1),
	'9':(1,1,1,1,0,1,1)}
	try:
	while True:
	n = time.ctime()[11:13]+time.ctime()[14:16]
	s = n.rjust(4)
	for digit in range(4):
	if (int(time.ctime()[18:19])%2 == 0) and (digit == 1):
	GPIO.output(25, 1)
	else:
	GPIO.output(25, 0)
	for loop in range(0,7):
	GPIO.output(segments[loop], num[s[digit]][loop])
	GPIO.output(digits[digit], 0)
	time.sleep(0.005)
	# The best sleep time for me to minimise flicker is 5 milliseconds
	GPIO.output(digits[digit], 1)
	finally:
	GPIO.cleanup()

view raw 4d7sCommonCathode.py hosted with ❤ by GitHub

You can see from lines 38 to 51 that the time.ctime() command is repeatedly executed, reading the time from the internet, in the form ‘Sat Nov 21 17:11:05 2015’.  

This is parsed to extract just the hour (17) and the minutes (11) and display these four digits.  The decimal point for the second digit (digit 1) is used to separate the minutes from the seconds and to flash every second.

The code loops, for each digit, each of its segments, and depending on whether the num dictionary specifies that segment to be 0 or 1 ie off or on, switches that segment on for 5 milliseconds.  This happens very fast, so each segment to go on, actually flashes on for 5 milliseconds in each loop.  This time.sleep(0.005) command is repeatedly executed until the time read from the internet changes (for example another second is updated).  So the LEDs are actually flashing repeatedly.  This is a form of Pulse Width Modulation, and the eye-brain system of an observer doesn't notice the flashes, but observes the segment of the digit as a steady light of constant brightness, even though the brightness of the flashes is much higher.  This has been described before as Persistence of Vision (POV).

Alex of course, goes on (see HERE) to make a count-down ticker, but still dizzy with excitement, I remembered that I had a spare 4-digit 7-segment LED Display so I dug it out.  It is of a different type, COMMON ANODE, as opposed to the COMMON CATHODE one above supplied by Alex.

So I started wondering how I could wire up my spare LED display, and realised that there was more to it than just a simple swap-over.  Before I risked blowing anything up, I consulted Alex.

Here is the internal circuit diagram for the COMMON CATHODE oue:

The diodes are arranged so that for each digit, DIG.1, DIG.2, DIG.3 and DIG.4, the cathodes are all connected together (to pin 12 for DIG.1, pin 9 for DIG.2 etc). Using wiring paths in this way, ie the same wires doing different things depending on the software logic, is known as multiplexing.

Here is the wiring diagram for the Common Cathode display:

Common Anode

The COMMON ANODE one looks like this:

Notice that the diodes are pointing from anodes which are common for each digit's 7 segments and decimal point, DP1, DP2, DP3 and DP4.  Also notice that there is a colon (L1 and L2) and an apostrophe (L3), but they aren't used here.

Here's my COMMON ANODE display connected to my Raspberry Pi 2:

You can just about see my black mini-breadboard with the resistors (this time 8x 680 Ω).

Here's a video:

PB213849 from Vimeo.

Here's the code for the COMMON ANODE setup:

	# S&S's version for a common ANODE 7-segment display driven by Raspberry Pi
	# code modified, tweaked and tailored from code by bertwert
	# on RPi forum thread topic 91796
	import RPi.GPIO as GPIO
	import time
	GPIO.setmode(GPIO.BCM)
	# GPIO ports for the 7seg pins
	segments = (11,4,23,8,7,10,18,25)
	# 7seg_segment_pins (14,16,13,3,5,11,15,7) + 670R inline
	for segment in segments:
	GPIO.setup(segment, GPIO.OUT)
	GPIO.output(segment, 1)
	# GPIO ports for the digit 0-3 pins
	digits = (22,27,17,24)
	# 7seg_digit_pins (1,2,6,8) digits 0-3 respectively
	for digit in digits:
	GPIO.setup(digit, GPIO.OUT)
	GPIO.output(digit, 0)
	# note these digits are all inverted compared with the common cathode display:
	num = {' ':(1,1,1,1,1,1,1),
	'0':(0,0,0,0,0,0,1),
	'1':(1,0,0,1,1,1,1),
	'2':(0,0,1,0,0,1,0),
	'3':(0,0,0,0,1,1,0),
	'4':(1,0,0,1,1,0,0),
	'5':(0,1,0,0,1,0,0),
	'6':(0,1,0,0,0,0,0),
	'7':(0,0,0,1,1,1,1),
	'8':(0,0,0,0,0,0,0),
	'9':(0,0,0,0,1,0,0)}
	try:
	while True:
	n = time.ctime()[11:13]+time.ctime()[14:16]
	s = n.rjust(4)
	for digit in range(4):
	if (int(time.ctime()[18:19])%2 == 0) and (digit == 1):
	GPIO.output(25, 0)
	else:
	GPIO.output(25, 1)
	for loop in range(0,7):
	GPIO.output(segments[loop], num[s[digit]][loop])
	GPIO.output(digits[digit], 1)
	time.sleep(0.005)
	GPIO.output(digits[digit], 0)
	finally:
	GPIO.cleanup()

view raw 4d7sCommonAnode.py hosted with ❤ by GitHub

Notice that a few changes have been made, mostly changing 0's to 1's and 1's to 0's. You'll see on Alex's post that I asked him for advice in doing this part, and he kindly responded and put me on the right track.  Thanks again Alex!

Here's the wiring diagram for the Common Anode Display:

And here is the Common Anode Display wired through the RasPiO Duino.  The Duino doesn't have anything to do with the 4-digit, 7-segment LED Display, but in fact it is running a sketch which is driving a darkness-enabled mood lamp (see the mood lamp made HERE previously):

Here's a video of this circuit working:

PB233854 from Vimeo.

The next step I want to make is to drive the LED Display with the Duino, which hopefully will be getting the time information from the internet via the Raspberry Pi.  Watch this space!

69. The Sense HAT's Inertial Measurement Unit

45,000 page views!!
I described this HAT (Hardware Attached on Top) for the Raspberry Pi a couple of posts ago (HERE).  Among its many goodies are a gyroscope, which measures momentum and rotation, an accelerometer which measures acceleration forces including that due to gravity, and a magnetometer, which measures the earth's magnetic field.

These three sensors make up what is collectively described as an Inertial Measurement Unit (IMU).  I have described the operation of the IMU in a previous post (No 53 HERE).  Three orthogonal axes are chosen, and rotational directions around these axes are known as roll, pitch and yaw.  Here is an illustration of the roll, pitch and yaw rotations of the Pi with the HAT fitted:

To further illustrate this, take as an example an aircraft, where roll describes the rotation about the direction of travel.  For example, when the wings go up on one side and down on the other: pitch is the motion when the nose of the plane goes up or down, and yaw describes a left or right turn.  They are the three orthogonal axes about which rotation of any object can be made, and combined rotations around all three axes give all the possible orientations that any body can have.  Here's a useful video to describe this:



So when the Raspberry Pi with its HAT on is tilted in various directions, the IMU can detect this and send the orientation data to the Raspberry Pi which can run software to represent this on a display.

I wrote a little Python script to make use of the 8 x 8 RGB LED display to indicate two of the rotations, pitch and roll.  Trying to represent yaw as well as pitch and roll on a 2D display is too difficult!  Here's the video:

You can see that my Pi 2B has the Raspberry Pi Camera Board attached, even though that's not needed for this project.

Here's my code:

	#!/usr/bin/python3
	from sense_hat import SenseHat
	sense = SenseHat()
	sense.clear()
	old_x = old_y = 0
	while True:
	o = sense.get_orientation()
	pitch = o["pitch"]
	roll = o["roll"]
	pitch_position = int(pitch/10.0)
	roll_position = int(roll/10.0)
	x = pitch_position % 8
	y = roll_position % 8
	if x <> old_x:
	sense.set_pixel(old_x, old_y, 0, 0, 0)
	if y <> old_y:
	sense.set_pixel(old_x, old_y, 0, 0, 0)
	old_x = x
	old_y - y
	sense.set_pixel(x, y, 255, 255, 255)

view raw KCledOrient.py hosted with ❤ by GitHub

While I was at it, I thought I would load up the 3D Apollo-Soyuz Demo, and it works well.  Here's the video (watch out for my thumb!):

You will have seen that I also have the 8 x 8 RGB LED array lit up, even though this also is not part of this project.

At the later part of the above video, I used the keyboard key " = " to rotate (yaw) the spacecraft in a clockwise direction.  I could equally have used the " - " key to offset the yaw of the spacecraft in a counter-clockwise direction.  Other keys that can be used are " a " which will toggle the accelerometer on and off, " g " to toggle the gyroscope on and off, and " m " to toggle the magnetometer on and off.  See how this facility is included in the code below (lines 62 to 74) by Ben Nuttall of the Raspberry Pi Foundation:

	#!/usr/bin/python3
	from sense_hat import SenseHat
	import math
	import pi3d
	sense = SenseHat()
	display = pi3d.Display.create()
	cam = pi3d.Camera.instance()
	shader = pi3d.Shader("mat_light")
	model = pi3d.Model(
	file_string="apollo-soyuz.obj",
	name="model", x=0, y=-1, z=40, sx=1, sy=1, sz=1)
	model.set_shader(shader)
	cam.position((0, 20, 0))
	cam.point_at((0, -1, 40))
	keyb = pi3d.Keyboard()
	compass = gyro = accel = True
	sense.set_imu_config(compass, gyro, accel)
	yaw_offset = 72
	while display.loop_running():
	o = sense.get_orientation_radians()
	if o is None:
	pass
	pitch = o["pitch"]
	roll = o["roll"]
	yaw = o["yaw"]
	yaw_total = yaw + math.radians(yaw_offset)
	sin_y = math.sin(yaw_total)
	cos_y = math.cos(yaw_total)
	sin_p = math.sin(pitch)
	cos_p = math.cos(pitch)
	sin_r = math.sin(roll)
	cos_r = math.cos(roll)
	abs_roll = math.degrees(math.asin(sin_p * cos_y + cos_p * sin_r * sin_y))
	abs_pitch = math.degrees(math.asin(sin_p * sin_y - cos_p * sin_r * cos_y))
	model.rotateToZ(abs_roll)
	model.rotateToX(abs_pitch)
	model.rotateToY(math.degrees(yaw_total))
	model.draw()
	keypress = keyb.read()
	if keypress == 27:
	keyb.close()
	display.destroy()
	break
	elif keypress == ord('m'):
	compass = not compass
	sense.set_imu_config(compass, gyro, accel)
	elif keypress == ord('g'):
	gyro = not gyro
	sense.set_imu_config(compass, gyro, accel)
	elif keypress == ord('a'):
	accel = not accel
	sense.set_imu_config(compass, gyro, accel)
	elif keypress == ord('='):
	yaw_offset += 1
	elif keypress == ord('-'):
	yaw_offset -= 1

view raw apollo-soyuz.py hosted with ❤ by GitHub

The code uses a file apollo-soyuz.obj which has all the necessary details of the spacecraft model to generate the display. Apparently it's possible to use Sketchup or Blender to make models and use them like this.  I must have a go at that!

Here is a depiction of the 1975 spacecraft of the first joint Soviet-USA space flight - Apollo /Soyuz  (and also the last Apollo mission, the Space Shuttle taking over after that):

Note that the diagram refers to Apollo 18.  Apollo 18 was actually cancelled, and in this joint mission it was simply referred to as Apollo.  This Apollo-Soyuz Test Project was successful, but Apollo got into a spot of bother on re-entry.  You can read about it HERE.

The 3D Apollo-Soyuz Demo is supplied as part of the Sense HAT (Astro Pi) software repository on GitHub.  See HERE.

Thanks Ben!

68. The RasPiO Duino HAT

44,000 page views!!
Here's the previously-mentioned HAT (Hardware Attached on Top) that has been developed by Alex Eames of RasPi.TV and RasP.iO.  This comes as a kit which is easy to solder together.  The aim with this was to make it easy to carry out Arduino programming on the Raspberry Pi.  So the scripts are in the Arduino language and are run on the built-in Atmel ATMEGA328P-PU (ie an Arduino) chip.

Having uploaded the Arduino sketch on the Arduino IDE from the Raspberry Pi, from that point on, the Pi itself does nothing more than supply power to the Arduino, although having said that, you could conceivably have Pi software that interacts with the Arduino, or even does something completely different.

Depending on the software that you write, the hat could be removed and all it would need then would be power to continue running the sketch.  For £14 (delivered) within the UK, it represents great value.

There is an extremely clearly written e-book (Learning Arduino Programming with RasPiO Duino) available HERE.  The book brings you from the very simple Blink sketch right up to using the analog inputs for fading LEDs using pulse-width modulation (PWM) and taking advantage of the eye-brain system's persistence of vision |(POV), previously explained in my post 15 HERE.

The sketch I am demonstrating is almost identical to my ATTiny85 code which I used in that post, which came originally from Instructables.com HERE.

Here's a picture of the RasPiO Duino hat mounted on my Raspberry Pi B+:

You can see that I have made use of the RasPiO Duino's prototyping area (with lots of holes) to make connections to the RGB LED common cathode to GND and the red, green and blue anodes to the Arduino pins 11, 10 and 9, through 330Ω resistors, on the blue mini-breadboard.  Instead of using the mini-breadboard, the RasPiO Duino's prototyping area could have been used instead.

There's also a light dependent resistor (LDR) shown at the bottom centre, connected in series with a 10kΩ resistor to GND at one end, and Arduino pin 3 at the other end.  In the above picture, the RGB LED is hidden under a light diffuser (A draft Guinness can widget). I also keep a 2 inch length of heat shrink over the LDR so that I can see the mood lamp working during the daylight hours.

The idea is of course, to program, through the Raspberry Pi, the Arduino chip, as a night-time mood lamp, cycling through all the colours in turn, provided there is minimal light reaching the LDR.

Here's a video where all is revealed:

and here's the code:

	//RasPiO Duino RGB color fading Mood Light NOW WITH LIGHT SENSING CAPABILITIES!!!
	const int redPin = 11;
	const int grnPin = 10;
	const int bluPin = 9;
	const int sensor = 3;
	void setup()
	{
	pinMode(redPin, OUTPUT);
	pinMode(grnPin, OUTPUT);
	pinMode(bluPin, OUTPUT);
	pinMode(sensor, INPUT);
	}
	void loop() {
	if (analogRead(sensor) <= 750)
	{
	redtoyellow();
	yellowtogreen();
	greentocyan();
	cyantoblue();
	bluetomagenta();
	magentatored();
	}
	else if (analogRead(sensor) >= 751)
	{
	digitalWrite(redPin, LOW);
	digitalWrite(grnPin, LOW);
	digitalWrite(bluPin, LOW);
	}
	}
	void redtoyellow()
	{
	digitalWrite(redPin, HIGH);
	digitalWrite(bluPin, LOW);
	// fade up green
	for(byte i=1; i<100; i++) {
	byte on = i;
	byte off = 100-on;
	for( byte a=0; a<100; a++ ) {
	digitalWrite(grnPin, HIGH);
	delayMicroseconds(on);
	digitalWrite(grnPin, LOW);
	delayMicroseconds(off);
	}
	}
	}
	void yellowtogreen()
	{
	digitalWrite(grnPin, HIGH);
	digitalWrite(bluPin, LOW);
	// fade down red
	for(byte i=1; i<100; i++) {
	byte on = 100-i;
	byte off = i;
	for( byte a=0; a<100; a++ ) {
	digitalWrite(redPin, HIGH);
	delayMicroseconds(on);
	digitalWrite(redPin, LOW);
	delayMicroseconds(off);
	}
	}
	}
	void greentocyan()
	{
	digitalWrite(grnPin, HIGH);
	digitalWrite(redPin, LOW);
	// fade up blue
	for(byte i=1; i<100; i++) {
	byte on = i;
	byte off = 100-on;
	for( byte a=0; a<100; a++ ) {
	digitalWrite(bluPin, HIGH);
	delayMicroseconds(on);
	digitalWrite(bluPin, LOW);
	delayMicroseconds(off);
	}
	}
	}
	void cyantoblue()
	{
	digitalWrite(bluPin, HIGH);
	digitalWrite(redPin, LOW);
	// fade down green
	for(byte i=1; i<100; i++) {
	byte on = 100-i;
	byte off = i;
	for( byte a=0; a<100; a++ ) {
	digitalWrite(grnPin, HIGH);
	delayMicroseconds(on);
	digitalWrite(grnPin, LOW);
	delayMicroseconds(off);
	}
	}
	}
	void bluetomagenta()
	{
	digitalWrite(bluPin, HIGH);
	digitalWrite(grnPin, LOW);
	// fade up red
	for(byte i=1; i<100; i++) {
	byte on = i;
	byte off = 100-on;
	for( byte a=0; a<100; a++ ) {
	digitalWrite(redPin, HIGH);
	delayMicroseconds(on);
	digitalWrite(redPin, LOW);
	delayMicroseconds(off);
	}
	}
	}
	void magentatored()
	{
	digitalWrite(redPin, HIGH);
	digitalWrite(grnPin, LOW);
	// fade down blue
	for(byte i=1; i<100; i++) {
	byte on = 100-i;
	byte off = i;
	for( byte a=0; a<100; a++ ) {
	digitalWrite(bluPin, HIGH);
	delayMicroseconds(on);
	digitalWrite(bluPin, LOW);
	delayMicroseconds(off);
	}
	}
	}

view raw KCMoodLamp.ino hosted with ❤ by GitHub

Must say, I do love mood lamps.  Thanks Instructibles.com, and thanks Alex.

67. The Sense HAT (Hardware Attached on Top)

HATs (Hardware Attached on Top) are the latest thing for the Raspberry Pi.  They are units of circuitry that neatly attach on to the Pi's 40 GPIO pins, which not only give very good mechanical stability, but also allows the relevant pins to be connected.  The last HAT I got was the RasPiO Duino by Alex Eames (see http://rasp.io/). It's a great piece of equipment which came as a kit, but is very easy to solder together.  There will be more about that later!

In the meantime, I'm on the learning curve for the Sense HAT, by the Raspberry Pi Foundation itself. There's a whole story about this, available HERE, so I'll not say much more than that it's the heart of the Astro Pi unit, two of which Tim Peake, UK astronaut, will be taking into space on the International Space Station at the end of this year.  So I just had to get one! (only £24.50 including delivery).

The Sense HAT has a number of goodies as follows:

• a 3DoF (degrees of freedom) Accelerometer, a 3 DoF Gyroscope and a 3 DoF Magnetometer
• a Temperature and Barometric Pressure sensor
• a Relative Humidity and Temperature sensor
• a 5-button miniature joystick
• a slot which allows the Raspberry Pi Camera Board to be connected simultaneously
• an 8 x 8 RGB LED array (nearly 200 LEDs!)
• an Atmel ATTINY88 micro controller unit (not re-programmable)

With the Python API and lots of documentation and code on GitHub, there's a wealth of stuff to be getting on with.  The mind just boggles with the possibilities of this machine!
Here's mine mounted on my Pi 2B, with my Raspberry Pi Camera Board also connected:

The Sense Hat mounted on a Pi 2 connected to monitor, WiFi, wireless keyboard and mouse, with the RasPiCam on top

The LEDs are actually displaying a multi-coloured display from rainbow.py.  It's difficult to get the exposure right with such bright LEDs - they all come out almost white.  There are a number of Python test scripts which can put the various sensors and input/output devices through their paces. Here's a video of my version of the astro_cam.py script running:

The video shows a white square outline surrounded by black, which I made on MS Excel and converted into a jpg.  The PiCam "sees" the pattern on my PC monitor, and the software converts it into an 8 x 8 array of pixels, displayed on the 64 RGB LED array, but also on the Pi's monitor, so that I can see what the PiCam sees.

There are a couple of things to note here - firstly the LED array image is not square, but squashed vertically into a rectangle.  This must be because of the viewing angle.  The other thing to note is that it's the top left of the image that is displayed.  This can no doubt be changed in the software. Additionally, the output picture on the Pi's monitor is pulsating.  This seems to happen in camera.start_preview() mode, the zoom appearing to vary with each pulse.  This could be an explanation of the squashed rectangle LED image, if that is truly what the PiCam sees.

Here's the Python script:

	import picamera
	from picamera import PiCamera
	from picamera.array import PiRGBArray
	from sense_hat import SenseHat
	sense = SenseHat()
	camera = picamera.PiCamera()
	def preview():
	camera.preview_fullscreen= False
	camera.preview_window = (170, -120, 860, 950)
	camera.video_stabilization = True
	camera.start_preview()
	preview()
	while True:
	# preview()
	# with PiCamera() as camera:
	camera.resolution = (64, 64)
	with PiRGBArray(camera, size=(8, 8)) as stream:
	camera.capture(stream, format='rgb', resize=(8, 8))
	image = stream.array
	pixels = [
	pixel
	for row in image
	for pixel in row
	]
	sense.set_pixels(pixels)

view raw astro_pi2.py hosted with ❤ by GitHub

To illustrate the ability of this system to reproduce colour, here is an example where the Raspberry Pi's startup image is reproduced:

As I said before, it's difficult to photograph the coloured LEDs so that the bright colours do not white-out. As viewed by the eye, the colours are much more convincing.

Other scripts I have tried so far include:

colour_cycle.py - this cycles the colours for all the LED pixels at the same time (ie all the same)

conway.py - a simple demonstration of the Conway Game of Life

env.py - this script displays scrolling text showing the environmental readings for example, "Temperature = 36.2.   Pressure = 1025.6. Humidity =  32.5"

eyes.py - this is a simple animation of a pair of eyes

orientation.py - gives a contiunous print oyt on the terminal of pitch, roll and yaw of the Sense Hat

press_letter.py - outputs on the LED array, any letter or character entered on the keyboard

pygame_joystick.py - indicates on the LED array, which of the positions the joystick has been moved

rainbow.py - shows a beautiful animation of the colours of the rainbow moving across the array

random_sparkles.py - makes each pixel independently and randomly change colour

rotating_letter.py - makes a letter on the array and rotates it through 90 degree steps

rotation.py - makes an alphanumeric character rotate

shake.py - any movement of the Sense Hat causes an exclamation mark to be displayed on the array

text_scroll.py - makes inverted text scroll on the array

Most of these have been provided by Ben Nuttall of the Raspberry Pi Foundation - thanks Ben!

66. A Graphical User Interface, written in Python, for use with the Raspberry Pi Camera

42,000 page views!!
In the course of investigating the Pi's GPIO ports and also python Graphical User Interfaces (GUI), I thought I would re-visit the Raspberry Pi camera and see how I could exploit the software attributes of this magnificent piece of hardware, and include GPIO control at the same time.

Here is the physical setup:

As you can see, the Raspberry Pi Camera Module is connected through the Pimoroni Pibow Coupé Flotilla case case to the Pi 2.  The Pi's GPIO pins are connected to the Cyntech B+ 40-way Paddle Board and from that, connections from GND and GPIO17 are made to a mini breadboard containing a mini push button switch.
  
Here is a picture of the the GUI:

and here is a whole-screen shot:

The sunflower seedling in the pot was the subject of a one week time lapse sequence of 2-hour delayed images, showing the birth of this seedling from a single seed.  The sequence of images was very impressive, and I would have liked to show them here, but unfortunately I lost all the images!  I'll try it again some time.

In the meantime, here's an animated GIF of a time lapse sequence of an internet clock, taken at 60 second intervals:

(I'm not sure what happened the alignment here - it looked nicely centred in the Preview).

Here's a better one, taken at 30 minute intervals:

You can see from the second hand in both the above examples, that a small delay introduced by the software increases the set interval by approximately one second each exposure.

Here is a shot where one example of the 22 available (including 'none') image effects - 'negative' - has been set:

You can see that on the left of the screen, there is an indication (in the LXTerminal) of values of such things as Brightness, Contrast, Saturation, Image Effect etc.

The "Set favourites" button returns all attributes (except Brightness, Contrast and Saturation) to their initial settings.

The "Demo" button starts a routine where the automatic white balance (awb) is changed for each 3-second preview, right through all 10 of the available effects (including "auto" and "off").  However, these camera.image_effect attributes do not seem to be operational currently, at least they don't seem to have any noticeable effect.

The "Quit" button cleanly exits the program, but only after any currently running routine has finished.  For example, the program would wait until a time lapse sequence would run through to the end before it terminates.

In addition to buttons in the GUI, I added some sliders, for Brightness, Contrast and Colour Saturation.  There is an additional slider at the bottom for setting the delay in seconds for time lapse sequences.  The maximum time lapse interval I have set is 7200, for 2-hour intervals.  This maximum time of course can be changed in the code.

The breadboard pushbutton is used for the "Take still" and "Take video" modes.  It is pushed to take a single still picture, with the settings displayed.  For recording video, the button is pressed once to start the video exposure, and then pressed again to finish the video sequence.  When the program is expecting a button push, it prints the message "Press the Button!" in the LXTerminal on the left of the screen.

The program uses the Tkinter library to draw the GUI elements such as buttons and sliders etc. The picamera library is invoked for using all the imaging attributes such as camera.brightness and so on.  RPi.GPIO of course is imported as the GPIO17 port is used for the pushbutton.

One nice little addition is the "LED" button which toggles the Camera Module's red LED on and off.  I used the statements camera.led = False and camera.led = True.

Finally you will see near the bottom of the GUI shown above, that there is a Motion detect button, followed by a slider labelled Threshold %.  The slider allows values between 1.5 and 2.5 per cent to be chosen.  The percentage refers to that of the image pixels which have to change before motion is considered to have been detected.  The button starts the motion detection part of the program.  The initial setting at line 20 of the code:

20 threshPercent=1.8 #This value is close to ideal for most cases

is 1.8 per cent, which is useful for detecting significant motion, without filling the Pi's SD card with hundreds of images.

Later I added the ability to zoom in on images, which works quite well, except I haven't found a way to centre the image after zooming,

I also added to my Pi Camera board, a zoom lens.  This gives reasonable magnification, but the image quality is a little disappointing.  I haven't got to the bottom of this yet, but here's an animated GIF image taken through the zoom lens and with motion detection::

Here are a couple of pictures of my 8 x zoom clip-on lens mounted on the Raspberry Pi Camera Board:

You can see in the first picture, the zoom lens clipped on to the camera board (and supported by a foil pie dish).  You can also see that the camera LED is on.  The second view shows the lens, Raspberry Pi in its case, and a push button mounted on a mini breadboard, through the Cyntech B+ 40-way Paddle Board (previously described in my Post 55 at http://smokespark.blogspot.co.uk/2014/10/55-.  The push button is for taking still shots or for starting and ending video recordings. (You can just about see out through the window, a couple of garden birds on my peanut bird feeder).

Here's the Python code:

	from Tkinter import *
	import time
	import picamera
	import RPi.GPIO as GPIO
	import numpy as np
	import io
	from datetime import datetime, timedelta
	GPIO.setwarnings(False)
	GPIO.setmode(GPIO.BCM)
	GPIO.setup(17, GPIO.IN, GPIO.PUD_UP)
	camera = picamera.PiCamera()
	ON = True
	zoom = 1.0
	previewTime = 3
	awbcount = 0
	effectno = 0
	delay = 5
	threshPercent = 1.8
	step = 1
	numImages = 1
	captureCount = 0
	numSav = 0
	def centre_window(w, h):
	ws = root.winfo_screenwidth()
	hs = root.winfo_screenheight()
	x = (ws/2) + 400
	y = (hs/2) - 285
	root.geometry('%dx%d+%d+%d' % (w, h, x, y))
	def brightUp():
	if camera.brightness < 100:
	camera.brightness += 5
	else:
	camera.brightness = 100
	w.set(camera.brightness)
	# print "Brightness", camera.brightness
	preview()
	def brightDown():
	if camera.brightness < 10:
	camera.brightness = 5
	else:
	camera.brightness -= 5
	# print "Brightness", camera.brightness
	w.set(camera.brightness)
	preview()
	def rotate():
	camera.rotation += 90
	print "Rotation", camera.rotation, "degrees"
	preview()
	def hflip():
	if camera.hflip == True:
	camera.hflip = False
	else:
	camera.hflip = True
	print "hFlip", camera.hflip
	preview()
	def vflip():
	if camera.vflip == True:
	camera.vflip = False
	else:
	camera.vflip = True
	print "vFlip", camera.vflip
	preview()
	def prevTime():
	global previewTime
	previewTime += 1
	print "Preview time", previewTime, "s"
	return previewTime
	preview()
	def preview():
	camera.preview_fullscreen = False
	camera.preview_window = (170, -120, 860, 950)
	camera.video_stabilization = True
	camera.brightness=w.get()
	camera.start_preview()
	print "Brightness",camera.brightness
	camera.contrast=y.get()
	print "Contrast",camera.contrast
	camera.saturation=xy.get()
	print "Saturation",camera.saturation
	for t in range (previewTime, 0, -1):
	camera.brightness = w.get()
	time.sleep(1)
	def still():
	print "Press the Button!"
	camera.preview_fullscreen = False
	camera.preview_window = (150, 50, 860, 540)
	camera.start_preview()
	GPIO.wait_for_edge(17, GPIO.FALLING)
	time.sleep(1)
	print "Brightness",camera.brightness
	print "Contrast",camera.contrast
	camera.capture('/home/pi/Desktop/images/image.jpg')
	camera.stop_preview()
	def vid():
	print "Press the Button!"
	camera.preview_fullscreen = False
	camera.preview_window = (150, 50, 860, 540)
	camera.start_preview()
	GPIO.wait_for_edge(17, GPIO.FALLING)
	camera.start_recording('/home/pi/Desktop/images/video.h264')
	time.sleep(1)
	GPIO.wait_for_edge(17, GPIO.FALLING)
	camera.stop_recording()
	camera.stop_preview()
	def sat():
	camera.saturation=xy.get()
	if camera.saturation < -99:
	camera.saturation += 5
	elif camera.saturation > 99:
	camera.saturation -= 5
	else:
	camera.saturation +=5
	xy.set(camera.saturation)
	preview()
	def sharp():
	camera.sharpness += 10
	print "Sharpness", camera.sharpness
	preview()
	def zoomIn():
	global zoom
	ws = root.winfo_screenwidth()
	hs = root.winfo_screenheight()
	if zoom >= 0.7:
	zoom -= 0.05
	x = (ws/2) - 0.5 * 400/(1 - zoom)
	y = (hs/2) - 0.5 * 285/(1 - zoom)
	camera.zoom = (x, y, zoom, zoom)
	print "Zoom", zoom, "%"
	else:
	print "Max zoom!"
	zoom = 0.7
	print "Zoom", zoom, "%"
	preview()
	def zoomOut():
	global zoom
	ws = root.winfo_screenwidth()
	hs = root.winfo_screenheight()
	if zoom <= 1.3:
	zoom += 0.05
	x = (ws/2) - 0.5 * 400/(1 - zoom)
	y = (hs/2) - 0.5 * 285/(1 - zoom)
	camera.zoom = (x, y, zoom, zoom)
	print "Zoom", zoom, "%"
	else:
	print "Min zoom!"
	zoom = 1.3
	print "Zoom", zoom, "%"
	preview()
	def contrast():
	camera.contrast = y.get()
	if camera.contrast < -99:
	camera.contrast += 5
	elif camera.contrast > 99:
	camera.contrast -= 5
	else:
	camera.contrast += 5
	print "Contrast", camera.contrast
	y.set(camera.contrast)
	preview()
	def led():
	global ON
	if ON == True:
	camera.led = False
	ON = False
	else:
	ON = True
	camera.led = True
	print "LED on", ON
	def fav():
	global previewTime
	previewTime = 3
	print "Preview time",previewTime
	camera.brightness = w.get()
	print "Brightness",camera.brightness
	camera.rotation = 0
	print "Rotation",camera.rotation
	camera.hflip = False
	print "hFlip",camera.hflip
	camera.vflip = False
	print "vFlip",camera.vflip
	camera.saturation = 0
	print "Saturation",camera.saturation
	camera.sharpness = 0
	print "Sharpness",camera.sharpness
	camera.contrast = y.get()
	print "Contrast",camera.contrast
	camera.AWB_MODES['auto']
	print "AWB auto"
	camera.image_effect = 'none'
	print "Image effect",camera.image_effect
	preview()
	def awb():
	global awbcount
	awbcount += 1
	if awbcount == 1:
	camera.AWB_MODES['auto']
	print "AWB auto"
	elif awbcount == 2:
	camera.AWB_MODES['sunlight']
	print "Sunlight"
	elif awbcount == 3:
	camera.AWB_MODES['cloudy']
	print "Cloudy"
	elif awbcount == 4:
	camera.AWB_MODES['shade']
	print "Shade"
	elif awbcount == 5:
	camera.AWB_MODES['tungsten']
	print "Tungsten"
	elif awbcount == 6:
	camera.AWB_MODES['fluorescent']
	print "Fluorescent"
	elif awbcount == 7:
	camera.AWB_MODES['incandescent']
	print "Incandescent"
	elif awbcount == 8:
	camera.AWB_MODES['flash']
	print "Flash"
	elif awbcount == 9:
	camera.AWB_MODES['horizon']
	print "Horizon"
	elif awbcount == 10:
	camera.AWB_MODES['off']
	print "Off"
	else:
	awbcount = 0
	preview()
	def effects():
	global effectno
	effectno += 1
	if effectno == 1:
	camera.image_effect = 'none'
	elif effectno == 2:
	camera.image_effect = 'negative'
	elif effectno == 3:
	camera.image_effect = 'solarize'
	elif effectno == 4:
	camera.image_effect = 'sketch'
	elif effectno == 5:
	camera.image_effect = 'denoise'
	elif effectno == 6:
	camera.image_effect = 'emboss'
	elif effectno == 7:
	camera.image_effect = 'oilpaint'
	elif effectno == 8:
	camera.image_effect = 'hatch'
	elif effectno == 9:
	camera.image_effect = 'gpen'
	elif effectno == 10:
	camera.image_effect = 'pastel'
	elif effectno == 11:
	camera.image_effect = 'watercolor'
	elif effectno == 12:
	camera.image_effect = 'film'
	elif effectno == 13:
	camera.image_effect = 'blur'
	elif effectno == 14:
	camera.image_effect = 'saturation'
	elif effectno == 15:
	camera.image_effect = 'colorswap'
	elif effectno == 16:
	camera.image_effect = 'washedout'
	elif effectno == 17:
	camera.image_effect = 'posterise'
	elif effectno == 18:
	camera.image_effect = 'colorpoint'
	elif effectno == 19:
	camera.image_effect = 'colorbalance'
	elif effectno == 20:
	camera.image_effect = 'cartoon'
	elif effectno == 21:
	camera.image_effect = 'deinterlace1'
	elif effectno == 22:
	camera.image_effect = 'deinterlace2'
	print "image effect",camera.image_effect
	preview()
	def demo():
	for x in range(1, 10):
	awb()
	preview()
	time.sleep(3)
	def wait():
	# Calculate the delay to the start of the next hour
	global delay
	# next_hour = (datetime.now() + timedelta(hours=1)).replace(minute=0, second=0, microsecond=0)
	delay = yy.get()
	# delay = (next_hour - datetime.now()).seconds
	time.sleep(delay)
	def lapse():
	preview()
	wait()
	try:
	while True:
	for filename in camera.capture_continuous('/home/pi/Desktop/images/{timestamp:%d-%m-%H:%M:%S}.jpg'):
	print('%s' % filename[24:])
	wait()
	except KeyboardInterrupt:
	print " CTRL-C detected"
	GPIO.cleanup()
	exit()
	def filenames():
	frame = 0
	fileName = time.strftime("/home/pi/Desktop/images/%d-%m-%Y:%H:%M:%S",time.localtime())
	while frame < 1:
	yield '%s%00d.jpg' % (fileName, frame)
	frame += 1
	def motion():
	global numImages
	global step
	global captureCount
	global numSav
	global threshPercent
	widthH = 2592
	heightH = 1944
	width = 1440
	height = 1080
	threshold = 30
	threshPercent = zz.get()
	minPixelsChanged = width * height * threshPercent/100 # increase the percentage for less motion sensitivity
	print "Minimum no of Pixels to be Changed=",int(minPixelsChanged)," ie: ",minPixelsChanged/(width*height)*100 ,"%"
	print "Creating in-memory stream"
	stream = io.BytesIO()
	time.sleep(1)
	try:
	while threshold > 0:
	camera.resolution = (1440, 1080)
	print "Cap:", numImages,
	if step == 1:
	stream.seek(0)
	camera.capture(stream, 'rgba',True)
	data1 = np.fromstring(stream.getvalue(), dtype=np.uint8)
	step = 2
	else:
	stream.seek(0)
	camera.capture(stream, 'rgba',True)
	data2 = np.fromstring(stream.getvalue(), dtype=np.uint8)
	step = 1
	numImages = numImages + 1
	if numImages > 4:
	if captureCount <= 0:
	data3 = np.abs(data1 - data2)
	numTriggers = np.count_nonzero(data3 > threshold) / 4 / threshold
	motionThreshold = int(numTriggers*100/minPixelsChanged)
	print "Trig:",motionThreshold,'%', "Img:",numSav," \r"
	if numTriggers > minPixelsChanged:
	captureCount = 1
	if captureCount > 0:
	camera.resolution = (width, height)
	dtFileStr = time.strftime("/home/pi/Desktop/images/%d-%m-%Y:%H:%M:%S.jpg",time.localtime())
	print "Saved:",dtFileStr
	camera.capture_sequence(filenames(),'jpeg',use_video_port=True,quality=92)
	captureCount = captureCount-1
	numSav += 1
	except KeyboardInterrupt:
	print " CTRL-C detected"
	GPIO.cleanup()
	exit()
	finally:
	camera.close()
	print ("Program Terminated")
	root = Tk()
	root.title("Pi Camera")
	centre_window(225, 530)
	quitButton = Button(root, bg="pink", text=" Quit ", command=exit)
	quitButton.grid(row=0, column=0)
	previewButton = Button(root, text=" Preview ", command=preview)
	previewButton.grid(row=1, column=1)
	rotateButton = Button(root, text=" Rotate ", command=rotate)
	rotateButton.grid(row=1, column=0)
	hflipButton = Button(root, text=" hFlip ", command=hflip)
	hflipButton.grid(row=2, column=0)
	vflipButton = Button(root, text=" vFlip ", command=vflip)
	vflipButton.grid(row=2, column=1)
	brightUpButton = Button(root, text=" Brighten ", command=brightUp)
	brightUpButton.grid(row=3, column=0)
	brightDownButton = Button(root, text=" Darken ", command=brightDown)
	brightDownButton.grid(row=3, column=1)
	takeVideoButton = Button(root, text=" Sharpness ", command=sharp)
	takeVideoButton.grid(row=4, column=0)
	contrastButton = Button(root, text=" Contrast ", command=contrast)
	contrastButton.grid(row=4, column=1)
	takeVideoButton = Button(root, text=" Effects ", command=effects)
	takeVideoButton.grid(row=5, column=0)
	saturationButton = Button(root, text=" Saturation ", command=sat)
	saturationButton.grid(row=5, column=1)
	ledButton = Button(root, text=" LED ", command=led)
	ledButton.grid(row=6, column=0)
	takeVideoButton = Button(root, text=" Quality ", command=contrast)
	takeVideoButton.grid(row=6, column=1)
	favouriteButton = Button(root, text="Set favourites", command=fav)
	favouriteButton.grid(row=7, column=0)
	demoButton = Button(root, text=" Demo ", command=demo)
	demoButton.grid(row=7, column=1)
	w = Scale(root, from_=25, to=75, resolution=1, orient=HORIZONTAL)
	w.grid(row=9, column=1)
	w.set(camera.brightness)
	print "Brightness", camera.brightness
	x = Label(root, text="Brightness")
	x.grid(row=9, column=0)
	y = Scale(root, from_=-50, to=50, resolution=1, orient=HORIZONTAL)
	y.grid(row=10, column=1)
	y.set(camera.contrast)
	print "Contrast", camera.contrast
	z = Label(root, text="Contrast")
	z.grid(row=10, column=0)
	xy = Scale(root, from_=-100, to=100, resolution=1, orient=HORIZONTAL)
	xy.grid(row=11, column=1)
	xy.set(camera.saturation)
	print "Saturation", camera.saturation
	xz = Label(root, text="Saturation")
	xz.grid(row=11, column=0)
	takeStillButton = Button(root, text=" Take still ", command=still)
	takeStillButton.grid(row=20, column=0)
	takeVideoButton = Button(root, text=" Take video ", command=vid)
	takeVideoButton.grid(row=20, column=1)
	yy = Scale(root, from_=0, to=7200, resolution=1, orient=HORIZONTAL)
	yy.grid(row=21, column=1)
	yy.set(delay)
	print "Delay", delay
	yz = Label(root, text="Timelapse delay s")
	yz.grid(row=21, column=0)
	takeStillButton = Button(root, text="Take timelapse", command=lapse)
	takeStillButton.grid(row=22, column=0)
	takeStillButton = Button(root, text="Motion detect ", command=motion)
	takeStillButton.grid(row=22, column=1)
	zz = Scale(root, from_=0.5, to=2.5, resolution=0.1, orient=HORIZONTAL)
	zz.grid(row=23, column=1)
	zz.set(threshPercent)
	print "Threshold percentage", threshPercent
	zx = Label(root, text="Threshold %")
	zx.grid(row=23, column=0)
	zoomInButton = Button(root, text = "Zoom in", command = zoomIn)
	zoomInButton.grid(row = 24, column = 0)
	zoomOutButton = Button(root, text = "Zoom out", command = zoomOut)
	zoomOutButton.grid(row = 24, column = 1)
	root.mainloop()

view raw workshop.py hosted with ❤ by GitHub

I will continue to develop this as there are more picamera.PiCamera() attributes that can be built in to this program.  Keep watching this space!

65. Driving Charlieplexed LEDs with the Raspberry Pi

33,000 page views!!
Do you remember a couple of years ago, when I built a set of Charlieplexed LEDs? Here's the post:http://smokespark.blogspot.co.uk/2013/08/32-charlieplexing-4-x-3-led-array.html
I was driving them with an Arduino and I thought I would try it with the Pi, as I'm on an exploration of the Pi's GPIO capabilities.

Here's a video of the result:

It's interesting that nothing is connected to GND - the four wires run to the four LED terminals from GPIO18, GPIO23, GPIO24 and GPIO25.  Current flows in different directions, depending on whether the software has set the ports to INPUT or OUTPUT, and if set to OUTPUT, whether that is set to HIGH or LOW..

As I have recently been interested in Python Graphical User Interfaces (GUIs), I also wrote a GUI for this exercise.  I have a grid of buttons, labelled 1 to 12, each one controlling its own personal LED, and which turn red when the corresponding LED is on.  So any one of the LEDs can be individually energised.

This also allows loops to be created, with sequences of lighting up the LEDs.  I made two further buttons, Loop - no delay and Loop - 0.1s delay, which both light up each LED in turn, and then continue this loop for a pre-set number of iterations.

The iterations can have a delay after lighting each LED, and this delay can be made zero, so that the lighting sequence is carried out as fast as the Pi can manage it.  With a zero delay, all the LEDs appear to light up together, albeit dimmer than one lit on its own, with only a slight flicker.  This is how persistence of vision (POV) can be used to fool the brain into thinking that they are all illuminated at the same time. The image below shows all the buttons in my GUI, which include a Clear button, turning all the LEDs off, and a Quit button, which closes the program down properly:

  

and here's a photo showing LED no 4 lit up as the GUI above indicates.

Here's the code:

	# GPIO GUI by S&S 5-Apr-15
	from Tkinter import *
	import RPi.GPIO as GPIO
	import time
	GPIO.setwarnings(False)
	GPIO.setmode(GPIO.BCM)
	def turn1on():
	GPIO.setup(18, GPIO.OUT)
	GPIO.output(18, GPIO.LOW)
	GPIO.setup(23, GPIO.OUT)
	GPIO.output(23, GPIO.HIGH)
	GPIO.setup(24, GPIO.IN)
	GPIO.input(24)
	GPIO.setup(25, GPIO.IN)
	GPIO.input(25)
	def turn2on():
	GPIO.setup(18, GPIO.OUT)
	GPIO.output(18, GPIO.HIGH)
	GPIO.setup(23, GPIO.OUT)
	GPIO.output(23, GPIO.LOW)
	GPIO.setup(24, GPIO.IN)
	GPIO.input(24)
	GPIO.setup(25, GPIO.IN)
	GPIO.input(25)
	def turn3on():
	GPIO.setup(18, GPIO.IN)
	GPIO.input(18)
	GPIO.setup(23, GPIO.OUT)
	GPIO.output(23, GPIO.LOW)
	GPIO.setup(24, GPIO.OUT)
	GPIO.output(24, GPIO.HIGH)
	GPIO.setup(25, GPIO.IN)
	GPIO.input(25)
	def turn4on():
	GPIO.setup(18, GPIO.IN)
	GPIO.input(18)
	GPIO.setup(23, GPIO.OUT)
	GPIO.output(23, GPIO.HIGH)
	GPIO.setup(24, GPIO.OUT)
	GPIO.output(24, GPIO.LOW)
	GPIO.setup(25, GPIO.IN)
	GPIO.input(25)
	def turn5on():
	GPIO.setup(18, GPIO.IN)
	GPIO.input(18)
	GPIO.setup(23, GPIO.IN)
	GPIO.input(23)
	GPIO.setup(24, GPIO.OUT)
	GPIO.output(24, GPIO.LOW)
	GPIO.setup(25, GPIO.OUT)
	GPIO.output(25, GPIO.HIGH)
	def turn6on():
	GPIO.setup(18, GPIO.IN)
	GPIO.input(18)
	GPIO.setup(23, GPIO.IN)
	GPIO.input(23)
	GPIO.setup(24, GPIO.OUT)
	GPIO.output(24, GPIO.HIGH)
	GPIO.setup(25, GPIO.OUT)
	GPIO.output(25, GPIO.LOW)
	def turn7on():
	GPIO.setup(18, GPIO.OUT)
	GPIO.output(18, GPIO.LOW)
	GPIO.setup(23, GPIO.IN)
	GPIO.input(23)
	GPIO.setup(24, GPIO.OUT)
	GPIO.output(24, GPIO.HIGH)
	GPIO.setup(25, GPIO.IN)
	GPIO.input(25)
	def turn8on():
	GPIO.setup(18, GPIO.OUT)
	GPIO.output(18, GPIO.HIGH)
	GPIO.setup(23, GPIO.IN)
	GPIO.input(23)
	GPIO.setup(24, GPIO.OUT)
	GPIO.output(24, GPIO.LOW)
	GPIO.setup(25, GPIO.IN)
	GPIO.input(25)
	def turn9on():
	GPIO.setup(18, GPIO.IN)
	GPIO.input(18)
	GPIO.setup(23, GPIO.OUT)
	GPIO.output(23, GPIO.LOW)
	GPIO.setup(24, GPIO.IN)
	GPIO.input(24)
	GPIO.setup(25, GPIO.OUT)
	GPIO.output(25, GPIO.HIGH)
	def turn10on():
	GPIO.setup(18, GPIO.IN)
	GPIO.input(18)
	GPIO.setup(23, GPIO.OUT)
	GPIO.output(23, GPIO.HIGH)
	GPIO.setup(24, GPIO.IN)
	GPIO.input(24)
	GPIO.setup(25, GPIO.OUT)
	GPIO.output(25, GPIO.LOW)
	def turn11on():
	GPIO.setup(18, GPIO.OUT)
	GPIO.output(18, GPIO.LOW)
	GPIO.setup(23, GPIO.IN)
	GPIO.input(23)
	GPIO.setup(24, GPIO.IN)
	GPIO.input(24)
	GPIO.setup(25, GPIO.OUT)
	GPIO.output(25, GPIO.HIGH)
	def turn12on():
	GPIO.setup(18, GPIO.OUT)
	GPIO.output(18, GPIO.HIGH)
	GPIO.setup(23, GPIO.IN)
	GPIO.input(23)
	GPIO.setup(24, GPIO.IN)
	GPIO.input(24)
	GPIO.setup(25, GPIO.OUT)
	GPIO.output(25, GPIO.LOW)
	def toggle1():
	greyall()
	turn1on()
	toggleButton1["background"] = "red"
	def toggle2():
	greyall()
	turn2on()
	toggleButton2["background"] = "red"
	def toggle3():
	greyall()
	turn3on()
	toggleButton3["background"] = "red"
	def toggle4():
	greyall()
	turn4on()
	toggleButton4["background"] = "red"
	def toggle5():
	greyall()
	turn5on()
	toggleButton5["background"] = "red"
	def toggle6():
	greyall()
	turn6on()
	toggleButton6["background"] = "red"
	def toggle7():
	greyall()
	turn7on()
	toggleButton7["background"] = "red"
	def toggle8():
	greyall()
	turn8on()
	toggleButton8["background"] = "red"
	def toggle9():
	greyall()
	turn9on()
	toggleButton9["background"] = "red"
	def toggle10():
	greyall()
	turn10on()
	toggleButton10["background"] = "red"
	def toggle11():
	greyall()
	turn11on()
	toggleButton11["background"] = "red"
	def toggle12():
	greyall()
	turn12on()
	toggleButton12["background"] = "red"
	def greyall():
	toggleButton1["background"] = "grey"
	toggleButton2["background"] = "grey"
	toggleButton3["background"] = "grey"
	toggleButton4["background"] = "grey"
	toggleButton5["background"] = "grey"
	toggleButton6["background"] = "grey"
	toggleButton7["background"] = "grey"
	toggleButton8["background"] = "grey"
	toggleButton9["background"] = "grey"
	toggleButton10["background"] = "grey"
	toggleButton11["background"] = "grey"
	toggleButton12["background"] = "grey"
	def turnalloff():
	# greyall()
	GPIO.setup(18, GPIO.OUT)
	GPIO.output(18, GPIO.LOW)
	GPIO.setup(23, GPIO.OUT)
	GPIO.output(23, GPIO.LOW)
	GPIO.setup(24, GPIO.OUT)
	GPIO.output(24, GPIO.LOW)
	GPIO.setup(25, GPIO.OUT)
	GPIO.output(25, GPIO.LOW)
	GPIO.setup(18, GPIO.IN)
	GPIO.input(18)
	GPIO.setup(23, GPIO.IN)
	GPIO.input(23)
	GPIO.setup(24, GPIO.IN)
	GPIO.input(24)
	GPIO.setup(25, GPIO.IN)
	GPIO.input(25)
	def turnallon0():
	delay = 0.0
	for x in range(0,500):
	toggle1()
	time.sleep(delay)
	turnalloff()
	toggle3()
	time.sleep(delay)
	turnalloff()
	toggle5()
	time.sleep(delay)
	turnalloff()
	toggle6()
	time.sleep(delay)
	turnalloff()
	toggle11()
	time.sleep(delay)
	turnalloff()
	toggle12()
	time.sleep(delay)
	turnalloff()
	toggle10()
	time.sleep(delay)
	turnalloff()
	toggle8()
	time.sleep(delay)
	turnalloff()
	toggle7()
	time.sleep(delay)
	turnalloff()
	toggle2()
	time.sleep(delay)
	turnalloff()
	toggle4()
	time.sleep(delay)
	turnalloff()
	toggle9()
	time.sleep(delay)
	turnalloff()
	toggle10()
	time.sleep(delay)
	turnalloff()
	toggle8()
	time.sleep(delay)
	turnalloff()
	toggle7()
	time.sleep(delay)
	turnalloff()
	toggle2()
	time.sleep(delay)
	turnalloff()
	greyall()
	def turnallon1():
	delay = 0.1
	for x in range(0,10):
	toggle1()
	time.sleep(delay)
	turnalloff()
	toggle3()
	time.sleep(delay)
	turnalloff()
	toggle5()
	time.sleep(delay)
	turnalloff()
	toggle6()
	time.sleep(delay)
	turnalloff()
	toggle11()
	time.sleep(delay)
	turnalloff()
	toggle12()
	time.sleep(delay)
	turnalloff()
	toggle10()
	time.sleep(delay)
	turnalloff()
	toggle8()
	time.sleep(delay)
	turnalloff()
	toggle2()
	time.sleep(delay)
	turnalloff()
	toggle4()
	time.sleep(delay)
	turnalloff()
	toggle9()
	time.sleep(delay)
	turnalloff()
	toggle10()
	time.sleep(delay)
	turnalloff()
	toggle8()
	time.sleep(delay)
	turnalloff()
	toggle7()
	time.sleep(delay)
	turnalloff()
	toggle9()
	time.sleep(delay)
	turnalloff()
	toggle10()
	time.sleep(delay)
	turnalloff()
	toggle8()
	time.sleep(delay)
	turnalloff()
	toggle7()
	time.sleep(delay)
	turnalloff()
	toggle2()
	time.sleep(delay)
	turnalloff()
	greyall()
	root = Tk()
	root.title("Charlie")
	turnalloff()
	quitButton = Button(root, text="Quit", command=exit)
	quitButton.grid(row=0, columnspan=5)
	clearAllButton = Button(root, text="Clear", command=turnalloff)
	clearAllButton.grid(row=1, columnspan=5)
	loopAllButton0 = Button(root, text="Loop - no delay", command=turnallon0)
	loopAllButton0.grid(row=2, columnspan=5)
	loopAllButton1 = Button(root, text="Loop - 0.1s delay", command=turnallon1)
	loopAllButton1.grid(row=3, columnspan=5)
	toggleButton1 = Button(root, text=" 1", command=toggle1, foreground="white", background="grey")
	toggleButton1.grid(row=4, column=1)
	toggleButton2 = Button(root, text=" 2", command=toggle2, foreground="white", background="grey")
	toggleButton2.grid(row=4, column=2)
	toggleButton3 = Button(root, text=" 3", command=toggle3, foreground="white", background="grey")
	toggleButton3.grid(row=5, column=1)
	toggleButton4 = Button(root, text=" 4", command=toggle4, foreground="white", background="grey")
	toggleButton4.grid(row=5, column=2)
	toggleButton5 = Button(root, text=" 5", command=toggle5, foreground="white", background="grey")
	toggleButton5.grid(row=6, column=1)
	toggleButton6 = Button(root, text=" 6", command=toggle6, foreground="white", background="grey")
	toggleButton6.grid(row=6, column=2)
	toggleButton7 = Button(root, text=" 7", command=toggle7, foreground="white", background="grey")
	toggleButton7.grid(row=4, column=3)
	toggleButton8 = Button(root, text=" 8", command=toggle8, foreground="white", background="grey")
	toggleButton8.grid(row=4, column=4)
	toggleButton9 = Button(root, text=" 9", command=toggle9, foreground="white", background="grey")
	toggleButton9.grid(row=5, column=3)
	toggleButton10 = Button(root, text="10", command=toggle10, foreground="white", background="grey")
	toggleButton10.grid(row=5, column=4)
	toggleButton11 = Button(root, text="11", command=toggle11, foreground="white", background="grey")
	toggleButton11.grid(row=6, column=3)
	toggleButton12 = Button(root, text="12", command=toggle12, foreground="white", background="grey")
	toggleButton12.grid(row=6, column=4)
	root.mainloop()

view raw charlie.py hosted with ❤ by GitHub

Here is a reminder of how Charlieplexing works with a very simple example of 2 LEDs:
Pairs of LEDs are connected in anti-parallel (as opposed to parallel) and when the current is driven in one direction (Pin 1 to Pin 2 in the diagram below), one diode allows current to pass (LED1 lights up) while LED2 does not.  Then when the current is reversed - ie from Pin 2 to Pin 1, LED1 does not allow current to pass, but LED2 does, and LED2 lights up this time.

So, by alternating the direction of relative polarity of Pin 1 and Pin 2, LED1 or LED2 can be made to glow.  

If 4 GPIO ports are available, then a 4 x 3 array of LEDs can be handled.  In general, if n ports are available, a Charlieplexed array of n x (n-1) LEDs can be driven.

This is the diagram I used to show the wiring of the 12 LEDs.  You will need to read GPIO18, 23, 24 & 25 for ArduinoPin2, 3,4 and 5.


Here's a reminder of the truth table for 4 x 3 Charlieplexed LEDs:

Pins:					LEDs:
GPIO:	18	23	24	25		1	2	3	4	5	6	7	8	9	10	11	12
	L	H	i	i		1	0	0	0	0	0	0	0	0	0	0	0
	H	L	i	i		0	1	0	0	0	0	0	0	0	0	0	0
	i	L	H	i		0	0	1	0	0	0	0	0	0	0	0	0
	i	H	L	i		0	0	0	1	0	0	0	0	0	0	0	0
	i	i	L	H		0	0	0	0	1	0	0	0	0	0	0	0
	i	i	H	L		0	0	0	0	0	1	0	0	0	0	0	0
	L	i	H	i		0	0	0	0	0	0	1	0	0	0	0	0
	H	i	L	i		0	0	0	0	0	0	0	1	0	0	0	0
	i	L	i	H		0	0	0	0	0	0	0	0	1	0	0	0
	i	H	i	L		0	0	0	0	0	0	0	0	0	1	0	0
	L	i	i	H		0	0	0	0	0	0	0	0	0	0	1	0
	H	i	i	L		0	0	0	0	0	0	0	0	0	0	0	1

The pins are set to either OUTPUT with a 3V3 potential (H) or zero V condition (L) or as INPUT (i).  Making a port an INPUT effectively turns it off in this case. The fact that there are 3 possibilities for port conditions is known as tri-state logic.

To address LED 1, GPIO18 needs to be set as an OUTPUT, in the LOW state, GPIO23 also needs to be set as an OUTPUT, but in the HIGH state.  Both GPIO24 and 25 need to be set as INPUTS.  Then to light up LED2, GPIO18 and 23 need to swap their states, and so on.

Thanks, Charlie! (Reference HERE).