def __initsensor(self):
try:
import sensor
accsensor=sensor.sensors()['AccSensor']
self.acc_sensor=sensor.Sensor(accsensor['id'],accsensor['category'])
self.acc_sensor.connect(self.__acc_cb)
except ImportError:
self.acc_result=""
def activate(self):
if not SENSOR_AVAILABLE:
appuifw.note(u"sensor data not available, using defaults!", 'info')
return False
self.active = True
appuifw.app.exit_key_handler = self.parent.exit_key_handler
try:
sensors = sensor.sensors()
if sensors.has_key('AccSensor'):
sensor_data = sensors['AccSensor']
self.sensor = sensor.Sensor(sensor_data['id'], sensor_data['category'])
self.sensor.connect(self.sensor_event)
except:
appuifw.note(u"could not connect to accelerometer!", 'error')
self.stop()
self.update()
return True
def __init__(self, play_mode, sock):
self.play_mode = play_mode
self.sock = sock
self.orientation = sensor.orientation.TOP
self.won = False
self.elapsed_time = 0.0
self.last_attack = 0.0
self.health = INITIAL_HEALTH
self.orientation_history = zeros(HISTORY_SIZE)
self.index = 0
self.game_over = False
self.quitting = False
volume_options = [[u"Volume off", 0], [u"Volume low", 1],
[u"Volume med", 2], [u"Volume high", 3]]
appuifw.app.exit_key_handler = self.quit
appuifw.app.menu = [(u"Choose skin",
tuple([(unicode(skin["skinName"].title()),
self.skin_changer(skin))
for skin in ui.SKINS])),
(u"Set volume",
tuple([(option[0],
self.volume_changer(option[1]))
for option in volume_options])),
(u"Back to the fight", self.back_to_fight),
(u"Back to main menu", self.quit)]
self.__timer = e32.Ao_timer()
self.event = None
self.eventlock = e32.Ao_lock()
axyz.connect(self.new_accel_data)
sensor_type = sensor.sensors()['RotSensor']
self.rotation_sensor = sensor.Sensor(sensor_type['id'],
sensor_type['category'])
self.rotation_sensor.set_event_filter(sensor.RotEventFilter())
self.rotation_sensor.connect(self.new_rotation_data)
self.tick()
def __init__(self):
appuifw.app.screen = "normal"
appuifw.app.menu = [(u"Translate", self.onTranslate),
(u"Source language", self.onSetSource),
(u"Target language", self.onSetTarget),
(u"Access point", self.onSetAccessPoint),
(u"Clear", self.onClear),
(u"Exit", self.onExit)]
self.lock = e32.Ao_lock()
self.text = appuifw.Text(u"")
self.text.font = "normal"
self.source = "en"
self.target = "da"
self.uiLang = "en"
self.sourceList = None
self.targetList = None
self.accessPointId = None
self.accessPoint = None
self.lastSensed = time.time()
self.accelerometer = None
self.minSensed = 0
self.maxSensed = 0
self.sensing = True
self.sortedLanguageLists = {}
self.restoreSettings()
self.setTitle()
appuifw.app.body = self.text
appuifw.app.exit_key_handler = self.onExit
# Install accelerometer sensor callback
try:
import sensor
accInfo = sensor.sensors()['AccSensor']
self.accelerometer = \
sensor.Sensor(accInfo['id'], accInfo['category'])
if 0: self.accelerometer.connect(self.onAccelerate)
except:
pass
self.lock.wait()
def __init__(self, play_mode, sock):
self.play_mode = play_mode
self.sock = sock
self.orientation = sensor.orientation.TOP
self.won = False
self.elapsed_time = 0.0
self.last_attack = 0.0
self.health = INITIAL_HEALTH
self.orientation_history = zeros(HISTORY_SIZE)
self.index = 0
self.game_over = False
self.quitting = False
volume_options = [[u"Volume off",0], [u"Volume low",1], [u"Volume med",2], [u"Volume high",3]]
appuifw.app.exit_key_handler = self.quit
appuifw.app.menu = [ (u"Choose skin", tuple([(unicode(skin["skinName"].title()), self.skin_changer(skin)) for skin in ui.SKINS]) ),
(u"Set volume", tuple([(option[0], self.volume_changer(option[1])) for option in volume_options]) ),
(u"Back to the fight", self.back_to_fight),
(u"Back to main menu", self.quit) ]
self.__timer = e32.Ao_timer()
self.event = None
self.eventlock = e32.Ao_lock()
axyz.connect(self.new_accel_data)
sensor_type = sensor.sensors()['RotSensor']
self.rotation_sensor = sensor.Sensor(sensor_type['id'],
sensor_type['category'])
self.rotation_sensor.set_event_filter(sensor.RotEventFilter())
self.rotation_sensor.connect(self.new_rotation_data)
self.tick()
else:
target = (address, services.values()[0])
print "Povezujem..." + str(target)
sock.connect(target)
print "OK."
def sensor_event(data):
global sock
text = "" + str(data["data_1"] / 4) + ";" + str(data["data_2"] / 4) + ";" + str(data["data_3"] / 4) + ";\n\r"
sock.send(text)
def keypress(event):
if event["scancode"] == key_codes.EScancodeLeftSoftkey:
if event["type"] == appuifw.EEventKeyDown:
text = "#levDOL\n\r"
else:
text = "#levGOR\n\r"
sock.send(text)
bt_povezi()
sensors = sensor.sensors()
acc = sensor.Sensor(sensors["AccSensor"]["id"], sensors["AccSensor"]["category"])
acc.connect(sensor_event)
canvas = appuifw.Canvas(event_callback=keypress)
appuifw.app.body = canvas
e32.ao_sleep(15000)
acc.disconnect()
def __init__(self):
self.options = [[
(u"New Game", self.menu_start),
(u"Game size:",
((u"Small (5x6)", lambda: self.menu_start(GAME_SMALL)),
(u"Normal (10x12)", lambda: self.menu_start(GAME_NORMAL)),
(u"Large (20x24)", lambda: self.menu_start(GAME_LARGE)))),
(u"Top-10", self.show_top10), (u"Settings", self.show_settings),
(u"About", self.menu_about), (u"Exit", self.cb_quit)
], [(u"Reset", self.top10_reset), (u"Back", self.cb_return_main)],
[(u"Change", self.handle_settings),
(u"Reset", self.settings_reset),
(u"Back", self.cb_return_main)]]
self.lb = appuifw.Listbox([u""], lambda: None)
appuifw.app.screen = 'full'
appuifw.app.orientation = 'portrait'
appuifw.app.title = u'Unity'
appuifw.app.exit_key_handler = self.cb_quit
appuifw.app.focus = cb_focus
appuifw.app.menu = self.options[0]
global canvas
canvas = appuifw.Canvas(redraw_callback=cb_handle_redraw)
appuifw.app.body = canvas
# Board uses top10
global top10
top10 = HighScore(FILE_TOP, TOP_ITEMS, 3)
# Board uses user_set.down
global user_set
user_set = MySettings(FILE_SET)
global board
board = Board()
board.initialize(GAME_SMALL)
global img
img = graphics.Image.new(canvas.size)
board.draw_board()
# Define keyboard shortcuts
canvas.bind(key_codes.EKeyLeftArrow,
lambda: board.make_move(MOVE_LEFT))
canvas.bind(key_codes.EKeyRightArrow,
lambda: board.make_move(MOVE_RIGHT))
canvas.bind(key_codes.EKeyUpArrow, lambda: board.make_move(MOVE_UP))
canvas.bind(key_codes.EKeyDownArrow,
lambda: board.make_move(MOVE_DOWN))
canvas.bind(key_codes.EKeyEnter, board.check_click)
canvas.bind(key_codes.EKeySelect, board.check_click)
canvas.bind(key_codes.EKeyBackspace, board.undo)
canvas.bind(key_codes.EKey5, self.menu_start)
canvas.bind(key_codes.EKey2, lambda: board.rotate(MOVE_UP))
canvas.bind(key_codes.EKey4, lambda: board.rotate(MOVE_LEFT))
canvas.bind(key_codes.EKey6, lambda: board.rotate(MOVE_RIGHT))
canvas.bind(key_codes.EKey8, lambda: board.rotate(MOVE_DOWN))
canvas.bind(key_codes.EKey5, self.menu_start)
canvas.bind(key_codes.EKeyStar, lambda: self.menu_start(GAME_SMALL))
canvas.bind(key_codes.EKey0, lambda: self.menu_start(GAME_NORMAL))
canvas.bind(key_codes.EKeyHash, lambda: self.menu_start(GAME_LARGE))
canvas.bind(key_codes.EKey3, lambda: board.jump_level(3))
# SENSOR init after everything else
if SENSOR:
# returns the dictionary of available sensors
sensors = sensor.sensors()
# "Support is device dependent, e.g. Nokia 5500 supports
# OrientationEventFilter and Nokia N95 supports RotEventFilter"
# Hox: Also N95 seems to support OrientationEventFilter
# Does this device have Accelerator Sensor
if sensors.has_key('AccSensor'):
global SENSOR_ACC
SENSOR_ACC = True
sensor_data = sensors['AccSensor']
self.sensor_acc = sensor.Sensor(sensor_data['id'],
sensor_data['category'])
# Set default filter
self.sensor_acc.set_event_filter(
sensor.OrientationEventFilter())
# Set my own event callback handler
self.sensor_acc.connect(handle_orientation)
# N82 Settings UI has minimum value 5 seconds
# Set timeour in 4 seconds
global g_screensaver_off
g_screensaver_off = True
timer_screen.after(4, handle_screensaver)
appuifw.app.screen = 'full'
appuifw.app.title = u'Paparazzi'
appuifw.app.exit_key_handler = cb_quit
appuifw.app.menu = [(u"New", game_init), (u"About", menu_about),
(u"Exit", cb_quit)]
canvas = appuifw.Canvas(redraw_callback=cb_handle_redraw)
appuifw.app.body = canvas
img = graphics.Image.new(canvas.size)
screen_x, screen_y = canvas.size
# SENSOR start init after everything else
if SENSOR:
x, y = screen_x, screen_y
# returns the dictionary of available sensors
sensors = sensor.sensors()
# Does this device have Accelerator Sensor
if sensors.has_key('AccSensor'):
SENSOR_ACC = True
sensor_data = sensors['AccSensor']
sensor_acc = sensor.Sensor(sensor_data['id'], sensor_data['category'])
sensor_acc.connect(handle_sensor_data)
# SENSOR finish init after everything else
canvas.bind(key_codes.EKeyEnter, game_init)
canvas.bind(key_codes.EKeySelect, game_init)
game_init()
app_lock = e32.Ao_lock()
import e32
import appuifw
import sensor
from sensor import orientation
orientations = {
orientation.TOP: 'top',
orientation.BOTTOM: 'bottom',
orientation.LEFT: 'left',
orientation.RIGHT: 'right',
orientation.FRONT: 'front',
orientation.BACK: 'back'
}
sensors_supported = sensor.sensors()
def test_sensors_supported():
print "Sensors supported on this device are: ", sensors_supported
def test_rotation_sensor():
def rotation_callback(orientation_value):
print 'New orientation: ', orientations[orientation_value]
if 'RotSensor' not in sensors_supported:
print "Rotation sensor not supported by this device"
return
rot_sensor_data = sensors_supported['RotSensor']
def __init__(self): sensors = sensor.sensors() self.sensor = sensor.Sensor(sensors["AccSensor"]["id"], sensors["AccSensor"]["category"]) self.cb = None self.sensor.connect(self.coord_cb)
# Echo client program
import socket
import sensor
import time
HOST = '192.168.1.100'
PORT = 50009
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((HOST, PORT))
sensor_type = sensor.sensors()['RotSensor']
N95_sensor = sensor.Sensor(sensor_type['id'], sensor_type['category'])
N95_sensor.set_event_filter(sensor.RotEventFilter())
direction = 'F'
def get_sensor_data (status):
global direction
if status == sensor.orientation.TOP:
direction = 'L'
elif status == sensor.orientation.LEFT:
direction = 'F'
elif status == sensor.orientation.BOTTOM:
direction = 'R'
elif status == sensor.orientation.RIGHT:
direction = 'Q'
def quit ():
N95_sensor.disconnect()
def __init__(self):
self.screen_size = 'full'
self.orientation = 'portrait'
appuifw.app.screen = self.screen_size
appuifw.app.title = NAME
appuifw.app.exit_key_handler = self.cb_quit
appuifw.app.focus = cb_focus
self.init_menu()
global canvas
canvas = appuifw.Canvas(redraw_callback=cb_handle_redraw)
# Calls automatically resize_callback and redraw_callback
appuifw.app.body = canvas
global img
if not img:
img = graphics.Image.new(canvas.size)
e32.ao_yield()
global board
board = Board(TILE_SIZE)
board.initialize()
handle_screensaver()
board.draw_board()
# Define keyboard shortcuts
canvas.bind(key_codes.EKeyLeftArrow,
lambda: board.handle_movement(MOVE_LEFT))
canvas.bind(key_codes.EKeyRightArrow,
lambda: board.handle_movement(MOVE_RIGHT))
canvas.bind(key_codes.EKeyUpArrow,
lambda: board.handle_movement(MOVE_UP))
canvas.bind(key_codes.EKeyDownArrow,
lambda: board.handle_movement(MOVE_DOWN))
canvas.bind(key_codes.EKeyEnter, lambda: self.query_newgame())
canvas.bind(key_codes.EKeySelect, lambda: self.query_newgame())
#############################################################
# SENSOR init after everything else
if SENSOR:
# returns the dictionary of available sensors
sensors = sensor.sensors()
# "Support is device dependent, e.g. Nokia 5500 supports
# OrientationEventFilter and Nokia N95 supports RotEventFilter"
# Hox: Also N95 seems to support OrientationEventFilter
# Does this device have Accelerator Sensor
if sensors.has_key('AccSensor'):
global SENSOR_ACC
global sensor_acc
SENSOR_ACC = True
sensor_data = sensors['AccSensor']
sensor_acc = \
sensor.Sensor(sensor_data['id'], sensor_data['category'])
# Orientation filter: up, down, left, right, front, back
#self.sensor_acc.set_event_filter(sensor.OrientationEventFilter())
# My callback handler, only for Orientation events
#sensor_acc.connect(self.handle_sensor_raw)
sensor_acc.connect(self.sensor_stabilizer)
