def send():
params = bottle.request.query
if 'text' not in params:
raise HTTPError(400, 'Need text to send!')
if 'label' in params:
label = params.label.lower()
else:
label = 'A'
text = params.text
color = constants.get_color(params.get('color', 'NONE'))
mode = constants.get_mode(params.get('mode', 'COMPRESSED_ROTATE'))
text = color + text
text = general.parse_colors(text)
if label == 'A':
text = parse_labels(text)
memory_entry = sign.find_entry(read_raw_memory_table(), label)
if len(text) >= memory_entry['size']:
raise HTTPError(
400, 'Not enough space allocated. Need at least %s bytes.' %
(len(text) + 1))
if label == 'A':
sign.write(alphasign.Text(text, label=label, mode=mode))
else:
sign.write(alphasign.String(text, label=label))
return {'result': 'Sucessfully sent text'}
def get_text(self):
# fixed width to allow matching things up across the two lines
return alphasign.Text(alphasign.charsets.FIXED_WIDTH_ON + self.top +
self.bot,
mode=alphasign.modes.AUTOMODE,
position=alphasign.positions.FILL,
label=self.label)
def reset():
params = bottle.request.query
text_length = params.get('textsize', 256, type=int)
string_length = params.get('stringsize', 256, type=int)
text = alphasign.Text(
'%sREADY FOR DEAD-SIMPLE. TRY HITTING %s/dead-simple/send?text=%s<text>'
% (alphasign.colors.RED, alphasign.colors.YELLOW,
alphasign.colors.GREEN),
label='A',
size=text_length,
mode=alphasign.modes.COMPRESSED_ROTATE)
strings = [
alphasign.String(label=label, size=string_length)
for label in constants.dead_simple_string_labels
]
sign.allocate(chain([text], strings))
sign.set_run_sequence([text])
sign.write(text)
for string in strings:
sign.write(string)
read_raw_memory_table.clear_cache()
return {'result': 'Successfully reset sign for dead-simple API'}
def __init__(self, usb_port=USB_PORT, max_size=10):
self.messages = []
self.sign = alphasign.Serial(USB_PORT)
# where in the queue are we?
self.index = 0
# where do we start
self.start_index = 0
self.sign.connect()
self.sign.clear_memory()
# how many 'live' messages do we have?
self.size = 0
self.max_size = max_size
label_num = 0
for i in range(self.max_size):
msg = {}
msg["str"] = alphasign.String(size=125,
label=chr(ord('A') + label_num))
label_num = label_num + 1
msg["txt"] = alphasign.Text(
"%s%s" % (alphasign.colors.GREEN, msg["str"].call()),
chr(ord('A') + label_num),
mode=alphasign.modes.ROTATE)
label_num = label_num + 1
self.messages.append(msg)
self.sign.allocate((msg["str"], msg["txt"]))
self.sign.write(msg["str"])
self.sign.write(msg["txt"])
print "alloc'ed: %s string, %s text" % (msg["str"], msg["txt"])
def handle(self):
# self.request is the TCP socket connected to the client
self.data = self.request.recv(1024).strip()
logging.info("{} wrote: {}".format(self.client_address[0], self.data))
msg = alphasign.Text(self.data)
sign.write(msg)
# ack
self.request.sendall("sign set to %s" % self.data)
def show_text(data):
label = data['label']
memory_entry = sign.find_entry(read_raw_memory_table(), label)
if memory_entry['type'] != 'TEXT':
raise HTTPError(
400,
'The data at label %s must be of type TEXT. It is of type %s' %
(label, memory_entry['type']))
sign.set_run_sequence([alphasign.Text(label=label)])
return {'result': 'Sign showing text at %s' % label}
def write_file(request, label):
memory_table = read_raw_memory_table()
if 'type' in request:
general.validate_label(label, request['type'], memory_table)
memory_entry = sign.find_entry(memory_table, label)
memory_table = sign.parse_raw_memory_table(memory_table)
file_type = memory_entry['type']
if file_type == 'TEXT' or file_type == 'STRING':
data = request['text']
#Prepend color. Ignore invalid colors.
data = constants.get_color(request.get('color', 'NO_COLOR')) + data
#parse colors
data = general.parse_colors(data)
#text-specific processing
if file_type == 'TEXT':
data = general.parse_labels(data, memory_table)
#check size
if len(data) > memory_entry['size']:
raise HTTPError(
400,
'Not enough memory allocated. Requires %s, only %s allocated.'
% (len(data), memory_entry['size']))
if file_type == 'TEXT':
mode = constants.get_mode(request.get('mode', 'HOLD'))
obj = alphasign.Text(data, label=label, mode=mode)
elif file_type == 'STRING':
obj = alphasign.String(data, label=label)
elif file_type == 'DOTS':
data = request['data']
rows = memory_entry['rows']
columns = memory_entry['columns']
obj = alphasign.Dots(rows, columns, label=label)
for i, row in enumerate(data[:rows]):
obj.set_row(i, row)
sign.write(obj)
return {'result': 'memory written successfully'}
def make_objects(clump, names=None):
'''Given a clump, generate the objects to be written to the sign.
'''
labels = iter(constants.sign_controller_labels)
text_label = next(labels)
fields = clump['fields']
text = clump['text']
label_map = {name: (next(labels), 'STRING' if 'text' in field else 'DOTS')
for name, field in sorted(fields.iteritems())}
#parse colors
text = general.parse_colors(text)
#parse labels
def label_replacer(flag):
if flag in label_map:
label, type = label_map[flag]
if type == 'STRING':
return alphasign.String(label=label).call()
elif type == 'DOTS':
return alphasign.Dots(label=label).call()
return None
text = general.parse_generic(text, label_replacer)
yield alphasign.Text(text, text_label,
mode=constants.get_mode(clump['mode']))
if names is not None:
label_map = {name: val for name, val in label_map.iteritems() if name in names}
#Run through each named subfield
for fieldname, (label, fieldtype) in label_map.iteritems():
field = fields[fieldname]
if fieldtype == 'DOTS':
rows = field['rows']
num_rows = len(rows)
num_columns = max(len(row) for row in rows)
dots = alphasign.Dots(num_rows, num_columns, label=label)
for i, row in enumerate(rows):
dots.set_row(i, str(row))
yield dots
elif fieldtype == 'STRING':
text = field['text']
text = general.parse_colors(text)
yield alphasign.String(text, label=label)
def update_sign():
sign = alphasign.Serial(device='/dev/ttyUSB0')
sign.connect()
sign.clear_memory()
# create an empty alphasign.String
alpha_str = alphasign.String(size=64)
# create a single alphasign.Text object with a placeholder for our alphasign.String
alpha_txt = alphasign.Text(alpha_str.call(),mode=alphasign.modes.COMPRESSED_ROTATE)
# allocate memory for these objects on the sign
sign.allocate((alpha_str,alpha_txt))
# tell sign to only display the text part
sign.set_run_sequence((alpha_txt,))
# write objects
for obj in (alpha_str,alpha_txt):
sign.write(obj)
# This gives time for the serial write to complete before we issue the next write.
time.sleep(5)
last_payload = ''
while True:
try:
# fetch new-line separated plain text from Interweb
payload = urllib2.urlopen("https://server.appletonmakerspace.org/wiki/doku.php?id=sign_text&do=export_raw").read()
except Exception as e:
payload = 'net err: '+str(e)
# alert bystanders with beep when we update
if payload != last_payload:
sign.beep(frequency=20, duration=1)
last_payload = payload
# loop over each line of plain text, displaying for 10 seconds
for line in payload.splitlines():
alpha_str.data = line
sign.write(alpha_str)
time.sleep(10)
def __init__(self, channel, nickname, password=''):
self.channel = channel
self.nickname = nickname
self.password = password
self.sign = alphasign.Serial(USB_PORT)
self.sign.connect()
self.sign.clear_memory()
self.message_str = alphasign.String(size=140, label="2")
self.message_txt = alphasign.Text("%s" % self.message_str.call(),
label="B",
mode=alphasign.modes.TWINKLE)
#message_txt = alphasign.Text("%s%s" % (alphasign.colors.GREEN,message_str.call()), label="B", mode = alphasign.modes.ROTATE)
self.message_str.data = "Make me say things!"
# allocate memory for these objects on the sign
self.sign.allocate((self.message_str, self.message_txt))
self.sign.set_run_sequence((self.message_txt, ))
self.sign.write(self.message_txt)
self.sign.write(self.message_str)
def set_allocation_table(request):
table = request['table']
allocation_objects = []
used_labels = []
for entry in table:
try:
label = entry['label']
object_type = entry['type'].upper()
general.validate_label(label)
if label in used_labels:
raise HTTPError(400, 'Label %s has already appeared in entry')
#TODO: check sizes
if object_type == 'TEXT':
obj = alphasign.Text(label=label, size=entry['size'])
elif object_type == 'STRING':
obj = alphasign.String(label=label, size=entry['size'])
elif object_type == 'DOTS':
obj = alphasign.Dots(entry['rows'],
entry['columns'],
label=label)
else:
raise HTTPError(400, '%s is not a valid type' % object_type)
allocation_objects.append(obj)
used_labels.append(label)
except KeyError as e:
raise HTTPError(
400, 'Missing Field %s in entry\nEntry:\n%s' %
(e.message, entry)), None, sys.exc_traceback
except HTTPError as e:
e.output += '\nEntry:\n%s' % entry
raise
sign.allocate(allocation_objects)
read_raw_memory_table.clear_cache()
return {'result': 'Memory allocated successfully'}
def updateLED(list):
sign = alphasign.Serial(0)
sign.connect()
print "Clearing sign memory"
#sign.clear_memory()
#sign.beep(frequency=0,duration=0.1,repeat=0)
#create the sequence
messages = []
for position, item in enumerate(list):
messageData = item
#cleanup the message a bit
#messageData = "%s" + " " + messageData + " "
messageData = "%s" + messageData
label = position + 1
messageText = alphasign.Text((messageData % alphasign.charsets.TEN_HIGH_STD),label=str(label),mode=checkMode(messageData),position=checkPosition(messageData))
#messageText = alphasign.Text(messageData % alphasign.charsets.SEVEN_SHADOW,label=str(label))
#messageText = alphasign.Text((messageData % alphasign.charsets.SEVEN_HIGH_FANCY),label="A")
print "Message Data: %s" % messageData
print str(position)
print "Position: %s" % position
messages.append(messageText)
# allocate memory for these objects on the sign
print "Allocating sign text"
sign.allocate((messages))
#print "Updating Sequence"
#sign.set_run_sequence((messages))
print "Writing messages"
for obj in (messages):
sign.write(obj)
# self.request is the TCP socket connected to the client
self.data = self.request.recv(1024).strip()
logging.info("{} wrote: {}".format(self.client_address[0], self.data))
msg = alphasign.Text(self.data)
sign.write(msg)
# ack
self.request.sendall("sign set to %s" % self.data)
if __name__ == "__main__":
public_ip = subprocess.check_output(['hostname', '-I']).strip()
logging.info("starting server on %s:%s" % (HOST, PORT))
sign = alphasign.interfaces.local.Serial(device='/dev/ttyUSB0', baudrate=38400)
sign.connect()
sign.clear_memory()
msg = alphasign.Text("%sserver %s:%s" % (alphasign.colors.RED, public_ip, PORT),
label="A",
mode=alphasign.modes.HOLD)
sign.write(msg)
# Create the server, binding to localhost on port 9999
server = SocketServer.TCPServer((HOST, PORT), MyTCPHandler)
# Activate the server; this will keep running until you
# interrupt the program with Ctrl-C
server.serve_forever()
def get_text(self):
return alphasign.Text(alphasign.speeds.SPEED_5 + self.text,
mode=alphasign.modes.SCROLL,
label=self.label)
import os
import json
import time
import datetime
import alphasign
sign = alphasign.Serial(device=os.environ["MZ_SIGN_PORT"])
sign.connect()
sign.clear_memory()
name_str = alphasign.String(size=50, label="1")
time_str = alphasign.String(size=20, label="2")
playing_text = alphasign.Text(
"Now Playing: {} {}".format(name_str.call(), time_str.call()),
label="A",
mode=alphasign.mode.ROLL_LEFT
)
sign_objs = (name_str, time_str, playing_text)
sign.allocate(objs)
sign.set_run_sequence((playing_text,))
for obj in sign_objs:
sign.write(obj)
redis = redis.Redis()
while True:
quent = redis.lindex("musicaqueue", 0)
if quent is None:
def get_text(self):
return alphasign.Text(self.text,
mode=alphasign.modes.AUTOMODE,
label=self.label)
def sign_loop(sign, module):
"""Main worker loop that feeds sequences to the sign.
"""
# there are 93 valid labels (see p. 50 of docs)
valid_labels = iter(
[chr(x) for x in range(0x20, 0x7E + 1) if x != 0x30 and x != 0x3F])
textfiles = []
for i in range(NUM_TEXTFILES):
textfiles.append(
alphasign.Text("",
size=125,
label="%s" % (valid_labels.next(), ),
mode=get_mode("HOLD")))
sign.allocate(textfiles)
run_sequence = textfiles[0:1]
sign.set_run_sequence(run_sequence)
for t in textfiles:
sign.write(t)
is_active = getattr(module, "is_active", lambda: True)
active = True
while not SHUTDOWN:
try:
# sleep and then skip to next iteration if not active
active = check_if_active(active, is_active, sign, textfiles)
if not active:
continue
try:
sequence = SEQUENCE_QUEUE.get(True, 1)
except Queue.Empty:
sequence = None
ctx = {'message_queue': MESSAGE_QUEUE}
if not sequence:
try:
sequence = module.sign_sequence(ctx)
except Exception as e:
LOG.error("Error running sign_sequence(): %s" % (str(e), ))
if not sequence:
sequence = {}
sleeptime = 60
messages = []
if sequence:
messages = sequence.get('messages', [])
num_msgs = len(messages)
if num_msgs > NUM_TEXTFILES:
LOG.info(
"WARNING: Got %d messages, which exceeds limit of %d. Truncating."
% (len(messages), NUM_TEXTFILES))
# modify run_sequence if necessary
if num_msgs != len(run_sequence):
LOG.debug("Re-setting run sequence")
run_sequence = textfiles[0:num_msgs]
sign.set_run_sequence(run_sequence)
sleeptime = int(sequence.get('duration', 60))
i = 0
for textfile in textfiles:
log = True
if i < len(messages):
msg = messages[i]
else:
msg = {'mode': 'HOLD', 'text': ''}
log = False
display_message(sign, msg, textfile, log=log)
i += 1
# let it display for given duration
sleep_for(sleeptime)
except KeyboardInterrupt:
LOG.info("Stopping...")
keep_going = False
LOG.info("Exiting sign loop")
