# Point-and-shoot camera for Raspberry Pi w/camera and Adafruit PiTFT.

# This must run as root (sudo python cam.py) due to framebuffer, etc.

#

# Adafruit invests time and resources providing this open source code,

# please support Adafruit and open-source development by purchasing

# products from Adafruit, thanks!

#

# http://www.adafruit.com/products/998 (Raspberry Pi Model B)

# http://www.adafruit.com/products/1367 (Raspberry Pi Camera Board)

# http://www.adafruit.com/products/1601 (PiTFT Mini Kit)

# This can also work with the Model A board and/or the Pi NoIR camera.

#

# Prerequisite tutorials: aside from the basic Raspbian setup and

# enabling the camera in raspi-config, you should configure WiFi (if

# using wireless with the Dropbox upload feature) and read these:

# PiTFT setup (the tactile switch buttons are not required for this

# project, but can be installed if you want them for other things):

# http://learn.adafruit.com/adafruit-pitft-28-inch-resistive-touchscreen-display-raspberry-pi

# Dropbox setup (if using the Dropbox upload feature):

# http://raspi.tv/2013/how-to-use-dropbox-with-raspberry-pi

#

# Written by Phil Burgess / Paint Your Dragon for Adafruit Industries.

# BSD license, all text above must be included in any redistribution.

#

# July 2014

# Implement a Battery Status Meter on the PiTFT 2.8" LCD used by this applicaation

#

# Hardware used is Sparkfun's LiPo Fuel Gauge (TOL-10617). Communications with

# with this device is accomplished via addition of I2C commands in this app.

# It will be necessary to set up I2C on the Raspberry Pi. Please refer to:

# http://learn.adafruit.com/adafruits-raspbery-pi-lesson-4-GPIO-setup/configuring-i2c

# The GPIO library is used as shown by the 'import PRi.GPIO as GPIO'

# The Adafruit_I2C class is used to initialize the device and provide basic

# Python I/O commands included with 'from Adafruit_I2C import Adafruit_I2C'.

#

# Also useful is the Adafruit lesson on 'Adding a Real Time Clock to Raspberry

# Pi at: https://learn.adafruit.com/adding-a-real-time-clock-to-raspberry-pi

# It provides information on installing, configuring and testing I2C devices.

#

# Additional hardware will be necessary to connect the Adafruit USB LiPo

# Charger (Product ID: 259) Status Pin 1 to GPIO 17 on the Raspberry Pi. It

# will be necessary to use a Logic Level Converter to protect the

# Raspberry Pi from voltages that exceed 3.3v; for example the 'Adafruit

# 4-channel I2C-safe Bi-directional Logic Level Converter' (Product ID: 757),

# or similar. Two of the channels om the Logic Level Converter may be used to

# shift the voltages on the i2c bus for connection to the Sparkfun Fuel Gauge.

# Otherwise, it will be necessary to remove the Pull-up Resisters: R5 and R6.

#

# Ten images will be added to the 'icons' folder to be used for the Battery

# charge status; both in charging and non-charging modes. These images are

# displayed in the upper right corner of Screen Mode 3 (Viewfinder).

#

# An Alarm LED can be connected to GPIO 18 to indicate the cam.py application

# needs to be shutdown and the battery chharged.

#

# Modifications by Edwin Whatley

# BSD license, all text above must be included in any redistribution.

import atexit

import cPickle as pickle

import errno

import fnmatch

import RPi.GPIO as GPIO

import io

import os

import picamera

import pygame

import smbus

import stat

import threading

import time

import yuv2rgb

from Adafruit_I2C import Adafruit_I2C

from pygame.locals import *

from subprocess import call

# UI classes ---------------------------------------------------------------

# Small resistive touchscreen is best suited to simple tap interactions.

# Importing a big widget library seemed a bit overkill. Instead, a couple

# of rudimentary classes are sufficient for the UI elements:

# Icon is a very simple bitmap class, just associates a name and a pygame

# image (PNG loaded from icons directory) for each.

# There isn't a globally-declared fixed list of Icons. Instead, the list

# is populated at runtime from the contents of the 'icons' directory.

class Icon:

pass

# Button is a simple tappable screen region. Each has:

# - bounding rect ((X,Y,W,H) in pixels)

# - optional background color and/or Icon (or None), always centered

# - optional foreground Icon, always centered

# - optional single callback function

# - optional single value passed to callback

# Occasionally Buttons are used as a convenience for positioning Icons

# but the taps are ignored. Stacking order is important; when Buttons

# overlap, lowest/first Button in list takes precedence when processing

# input, and highest/last Button is drawn atop prior Button(s). This is

# used, for example, to center an Icon by creating a passive Button the

# width of the full screen, but with other buttons left or right that

# may take input precedence (e.g. the Effect labels & buttons).

# After Icons are loaded at runtime, a pass is made through the global

# buttons[] list to assign the Icon objects (from names) to each Button.

class Button:

break

# UI callbacks -------------------------------------------------------------

# These are defined before globals because they're referenced by items in

# the global buttons[] list.

def isoCallback(n): # Pass 1 (next ISO) or -1 (prev ISO)

global isoMode

setIsoMode((isoMode + n) % len(isoData))

def settingCallback(n): # Pass 1 (next setting) or -1 (prev setting)

elif screenMode >= len(buttons): screenMode = 4

def fxCallback(n): # Pass 1 (next effect) or -1 (prev effect)

global fxMode

setFxMode((fxMode + n) % len(fxData))

def quitCallback(): # Quit confirmation button

raise SystemExit

def viewCallback(n): # Viewfinder buttons

takePicture()

def doneCallback(): # Exit settings

screenMode = 3 # Switch back to viewfinder mode

def imageCallback(n): # Pass 1 (next image), -1 (prev image) or 0 (delete)

showNextImage(n)

def deleteCallback(n): # Delete confirmation

loadIdx = -1

def storeModeCallback(n): # Radio buttons on storage settings screen

buttons[4][storeMode + 3].setBg('radio3-1')

def sizeModeCallback(n): # Radio buttons on size settings screen

camera.resolution = sizeData[sizeMode][1]

# camera.crop = sizeData[sizeMode][2]

# Global stuff -------------------------------------------------------------

functionMode = 1 # Current function mode; default = Still Camera

screenMode = 3 # Current screen mode; default = viewfinder

screenModePrior = -1 # Prior screen mode (for detecting changes)

settingMode = 4 # Last-used settings mode (default = storage)

storeMode = 0 # Storage mode; default = Photos folder

storeModePrior = -1 # Prior storage mode (for detecting changes)

sizeMode = 0 # Image size; default = Large

fxMode = 0 # Image effect; default = Normal

isoMode = 0 # ISO settingl default = Auto

iconPath = 'icons' # Subdirectory containing UI bitmaps (PNG format)

saveIdx = -1 # Image index for saving (-1 = none set yet)

loadIdx = -1 # Image index for loading

scaled = None # pygame Surface w/last-loaded image

batteryLevel = 0 # Image index for current Battery Level

batteryLast = 10 # Last Battery Level reading

Volt = 0.0 # Battery Voltage reading

Fuel = 0 # Battery Percentage reading

# To use Dropbox uploader, must have previously run the dropbox_uploader.sh

# script to set up the app key and such. If this was done as the normal pi

# user, set upconfig to the .dropbox_uploader config file in that account's

# home directory. Alternately, could run the setup script as root and

# delete the upconfig line below.

uploader = '/home/pi/Dropbox-Uploader/dropbox_uploader.sh'

upconfig = '/home/pi/.dropbox_uploader'

sizeData = [ # Camera parameters for different size settings

[(1440, 1080), (320, 240), (0.2222, 0.2222, 0.5556, 0.5556)]] # Small

isoData = [ # Values for ISO settings [ISO value, indicator X position]

[ 0, 27], [100, 64], [200, 97], [320, 137],

[400, 164], [500, 197], [640, 244], [800, 297]]

# A fixed list of image effects is used (rather than polling

# camera.IMAGE_EFFECTS) because the latter contains a few elements

# that aren't valid (at least in video_port mode) -- e.g. blackboard,

# whiteboard, posterize (but posterise, British spelling, is OK).

# Others have no visible effect (or might require setting add'l

# camera parameters for which there's no GUI yet) -- e.g. saturation,

# colorbalance, colorpoint.

fxData = [

'none', 'sketch', 'gpen', 'pastel', 'watercolor', 'oilpaint', 'hatch',

'negative', 'colorswap', 'posterise', 'denoise', 'blur', 'film',

'washedout', 'emboss', 'cartoon', 'solarize' ]

pathData = [

'/home/pi/Photos', # Path for storeMode = 0 (Photos folder)

'/boot/DCIM/CANON999', # Path for storeMode = 1 (Boot partition)

'/home/pi/Photos'] # Path for storeMode = 2 (Dropbox)

battData = [ # Battery Status and Charging

'batt100', 'batt75', 'batt50', 'batt25', 'batt0', 'batt100chg', 'batt75chg',

'batt50chg', 'batt25chg', 'batt0chg' ]

icons = [] # This list gets populated at startup

# buttons[] is a list of lists; each top-level list element corresponds

# to one screen mode (e.g. viewfinder, image playback, storage settings),

# and each element within those lists corresponds to one UI button.

# There's a little bit of repetition (e.g. prev/next buttons are

# declared for each settings screen, rather than a single reusable

# set); trying to reuse those few elements just made for an ugly

# tangle of code elsewhere.

buttons = [

]

# Assorted utility functions -----------------------------------------------

def setBatteryLevel(n):

buttons[3][0].setBg(battData[n])

buttons[3][0].draw(screen)

def setFxMode(n):

buttons[6][5].setBg('fx-' + fxData[fxMode])

def setIsoMode(n):

buttons[7][7].rect[1:])

def saveSettings():

pass

def loadSettings():

pass

# Scan files in a directory, locating JPEGs with names matching the

# software's convention (IMG_XXXX.JPG), returning a tuple with the

# lowest and highest indices (or None if no matching files).

def imgRange(path):

return None if min > max else (min, max)

# Busy indicator. To use, run in separate thread, set global 'busy'

# to False when done.

def spinner():

screenModePrior = -1 # Force refresh

def takePicture():

loadIdx = saveIdx

def showNextImage(direction):

t.join()

def showImage(n):

screenModePrior = -1 # Force screen refresh

def updFuelGauge():

pygame.display.update()

def i2cRead():

quitCallback()

def getFuelLevel():

t_i2c.start()

# Initialization -----------------------------------------------------------

# Init framebuffer/touchscreen environment variables

os.putenv('SDL_VIDEODRIVER', 'fbcon')

os.putenv('SDL_FBDEV' , '/dev/fb1')

os.putenv('SDL_MOUSEDRV' , 'TSLIB')

os.putenv('SDL_MOUSEDEV' , '/dev/input/touchscreen')

# Get user & group IDs for file & folder creation

# (Want these to be 'pi' or other user, not root)

s = os.getenv("SUDO_UID")

uid = int(s) if s else os.getuid()

s = os.getenv("SUDO_GID")

gid = int(s) if s else os.getgid()

# Buffers for viewfinder data

rgb = bytearray(320 * 240 * 3)

yuv = bytearray(320 * 240 * 3 / 2)

# Init pygame and screen

pygame.init()

pygame.mouse.set_visible(False)

screen = pygame.display.set_mode((0,0), pygame.FULLSCREEN)

# Init camera and set up default values

camera = picamera.PiCamera()

atexit.register(camera.close)

camera.resolution = sizeData[sizeMode][1]

#camera.crop = sizeData[sizeMode][2]

camera.crop = (0.0, 0.0, 1.0, 1.0)

# Leave raw format at default YUV, don't touch, don't set to RGB!

# Load all icons at startup.

for file in os.listdir(iconPath):

if fnmatch.fnmatch(file, '*.png'):

icons.append(Icon(file.split('.')[0]))

# Initialize I2C

try:

# print "Initialize I2C"

AdaI2C = Adafruit_I2C(0x36)

Adafruit_I2C.__init__(AdaI2C, 0x36)

AdaI2C.address = 0x36 # SparkFun "Fuel Gauge"

AdaI2C.bus = smbus.SMBus(Adafruit_I2C.getPiI2CBusNumber())

Adafruit_I2C.write16(AdaI2C, 0xFE, 0x0054) # POR register

Adafruit_I2C.write16(AdaI2C, 0x0C, 0x00FE) # RCOMP register

time.sleep(10)

# Initialize GPIO

GPIO.setmode(GPIO.BCM)

GPIO.setup(17, GPIO.IN) # Monitor Charging Status LED on LiPo Charger

GPIO.setup(18, GPIO.OUT) # Controls an Alarm LED during last 20% Battey Life

GPIO.output(18, GPIO.HIGH)

updFuelGauge()

getFuelLevel()

# print "Default I2C bus is accessible"

except:

# print "Error accessing default I2C bus"

pass

# Assign Icons to Buttons, now that they're loaded

for s in buttons: # For each screenful of buttons...

for b in s: # For each button on screen...

for i in icons: # For each icon...

if b.bg == i.name: # Compare names; match?

b.iconBg = i # Assign Icon to Button

b.bg = None # Name no longer used; allow garbage collection

if b.fg == i.name:

b.iconFg = i

b.fg = None

loadSettings() # Must come last; fiddles with Button/Icon states

# Main loop ----------------------------------------------------------------

while(True):

# Process touchscreen input

while True:

for event in pygame.event.get():

if(event.type is MOUSEBUTTONDOWN):

pos = pygame.mouse.get_pos()

for b in buttons[screenMode]:

if b.selected(pos): break

# If in viewfinder or settings modes, stop processing touchscreen

# and refresh the display to show the live preview. In other modes

# (image playback, etc.), stop and refresh the screen only when

# screenMode changes.

if screenMode >= 3 or screenMode != screenModePrior: break

# Refresh display

if screenMode >= 3: # Viewfinder or settings modes

stream = io.BytesIO() # Capture into in-memory stream

camera.capture(stream, use_video_port=True, format='raw')

stream.seek(0)

stream.readinto(yuv) # stream -> YUV buffer

stream.close()

yuv2rgb.convert(yuv, rgb, sizeData[sizeMode][1][0],

sizeData[sizeMode][1][1])

img = pygame.image.frombuffer(rgb[0:

(sizeData[sizeMode][1][0] * sizeData[sizeMode][1][1] * 3)],

sizeData[sizeMode][1], 'RGB')

elif screenMode < 2: # Playback mode or delete confirmation

img = scaled # Show last-loaded image

else: # 'No Photos' mode

img = None # You get nothing, good day sir

if img is None or img.get_height() < 240: # Letterbox, clear background

screen.fill(0)

if img:

screen.blit(img,

((320 - img.get_width() ) / 2,

(240 - img.get_height()) / 2))

# Overlay buttons on display and update

for i,b in enumerate(buttons[screenMode]):

b.draw(screen)

pygame.display.update()

screenModePrior = screenMode