def enablePoofer(self, msgObj):
try:
logger.info("Disabling poofer {}".format(msgObj["name"]))
self.disabled_poofers.remove(msgObj["name"])
self.writeDisabledPoofers()
event_manager.postEvent({"msgType":"poofer_enabled", "id":msgObj["name"]})
except KeyError as e:
pass
def disablePoofer(self, msgObj):
logger.info("Disabling poofer {}".format(msgObj["name"]))
if not msgObj["name"] in self.disabled_poofers:
self.disabled_poofers.append(msgObj["name"])
self.writeDisabledPoofers()
# XXX Rip this poofer out of the command list
# XXX self.pooferEvents
event_manager.postEvent({"msgType":"poofer_disabled", "id":msgObj["name"]})
def startFlameEffect(self, msgObj):
try:
sequenceName = msgObj["name"]
sequence = pattern_manager.getPattern(sequenceName)
if self.checkSequence(sequence):
self.setUpEvent(sequence)
event_manager.postEvent({"msgType":"sequence_start", "id":msgObj["name"]})
except Exception as e:
logger.exception("Failed to fetch or set up sequence.%s", str(e))
def stopAll(self):
try:
if not self.ser:
self.ser.initSerial()
if self.disableAllPoofersCommand == "":
self.generateDisableAllString()
self.ser.write(self.disableAllPoofersCommand.encode())
self.isFiringDisabled = True
self.pooferEvents = list() # reset all pooferEvents
event_manager.postEvent({"msgType":"global_pause", "id":"all?"})
except Exception as e:
logger.exception("Error stopping all poofers: %s", str(e))
def sequenceDisabled(sequenceName):
event_manager.postEvent({
"msgType": "sequence_disabled",
"id": sequenceName
})
def sequenceStop(sequenceName):
event_manager.postEvent({"msgType": "sequence_stop", "id": sequenceName})
def disablePoofer(pooferName):
event_manager.postEvent({"msgType": "poofer_disabled", "id": pooferName})
def turnOffPoofer(pooferName):
event_manager.postEvent({"msgType": "poofer_off", "id": pooferName})
def stopFlameEffect(self, msgObj):
event_manager.postEvent({"msgType":"sequence_stop", "id":msgObj["name"]})
filter(lambda p: p["sequence"] != msgObj["name"], self.pooferEvents)
def resumeAll(self):
self.isFiringDisabled = False
event_manager.postEvent({"msgType":"global_resume", "id":"all?"})
.format(gInAttractMode, gAutoAttractModeEnabled,
gAttractModeStartTime))
logger.debug(
"ATTRACT monitor. gInterruptible: {}".format(gInterruptable))
if __name__ == "__main__":
try:
logging.basicConfig(
format=
'%(asctime)-15s %(levelname)s %(module)s %(lineno)d: %(message)s',
level=logging.DEBUG)
event_manager.init()
hydraulics_drv.init()
init(2, True)
event_manager.postEvent({"msgType": "cpos", "x": 50, "y": 50, "z": 50})
time.sleep(5)
if gInAttractMode:
logger.debug("SUCCESS! In attract mode!")
else:
logger.debug("FAILURE! Not in attract mode")
event_manager.postEvent({
"msgType": "cpos",
"x": 500,
"y": 50,
"z": 50
})
time.sleep(1)
if not gInAttractMode:
logger.debug("SUCCESS! Not in attract mode!")
else:
def run(self):
''' Run the main driver thread - read from the linear position sensors and PID controllers,
write out to the linear position sensors. Also broadcast position information
to anyone who wants it.
This function is complicated by the fact that, depending on the mode, we may
be mapping various different inputs (sensor, recorded data, manual data) to various
different outputs (sensor, no output) or broadcasting different things (sensor,
recorded data). These different inputs and outputs have different units, which
means we need to translate between them if we have to do a mapping.
Here's a handy key:
- sensor data from the controller ranges from 400 to 2000 (that's in hundredths
of a milliamp)
- voltage data from the sculpture ranges from 0 to 660 (that's in hundredths of
a volt)
- Recorded data ranges from 0.0 to 1.0. These are unitless coordinates.
- The ADC converter goes from 0-4095. The maximum value for controller data is
3723. The maximum value for sculpture data is 4095.
In this code, 'control' needs to be in
'''
global control
while (self.running):
try:
self.spi.open(
0, 1
) # Open SPI Channel 1 Chip Select is GPIO-7 (CE_1), analog read
# Read input data
for index in range(0,
3): # Get mA Reading for Channels 1 thru 3
self.readAdc(index)
adc[index] = self.readAdc(index)
mA[index] = (adc[index] * mASpan / mASpanAdc)
# print "Reading %d = %0.2f mA" % (index+1,((float)(mA[index]))/Scaler) #XXX - put this in logs
for index in range(
4, 7): # Get Voltage reading for channels 5 thru 7
self.readAdc(index)
adc[index] = self.readAdc(index)
VDC[index] = (adc[index] * VDCSpan / VDCSpanAdc)
# print "Reading %d = %0.2f VDC" % (index+1,((float)(VDC[index]))/Scaler)
if inputSource == "recording":
playback_x, playback_y, playback_z = hydraulics_playback.getPlaybackData(
) # test state: send from playback data
control[0], control[1], control[2] = normalized_2_adcMA(
playback_x, playback_y, playback_z)
elif inputSource == "manual": # input range is 400-2000
control[0], control[1], control[2] = mA_2_adcMA(
manual_x, manual_y, manual_z)
else: # normal state, read from controller
control[0] = adc[0]
control[1] = adc[1]
control[2] = adc[2]
#print("INPUT: {}, {}, {}".format(adc[0],adc[1],adc[2]))
if feedbackSource == "recording":
if inputSource == "recording": # NB - dont call getPlaybackData twice
feedback_x = playback_x
feedback_y = playback_y
feedback_z = playback_z
else:
feedback_x, feedback_y, feedback_z = hydraulics_playback.getPlaybackData(
)
else: # Feedback source from PID controller
feedback_x, feedback_y, feedback_z = VDC_2_normalized(
VDC[4], VDC[5], VDC[6])
# send sculpture position to whoever is listening
nX, nY, nZ = adcMA_2_normalized(control[0], control[1],
control[2])
event_manager.postEvent({
"msgType": "pos",
"x": nX,
"y": nY,
"z": nZ,
"xx": feedback_x,
"yy": feedback_y,
"zz": feedback_z
})
event_manager.postEvent({
"msgType": "cpos",
"x": mA[0],
"y": mA[1],
"z": mA[2],
"xx": VDC[3],
"yy": VDC[4],
"zz": VDC[5]
})
# write to output
if outputEnabled:
logger.debug("writing output, {}, {}, {}".format(
control[0], control[1], control[2]))
self.writeAnalogOutput(4, 0, control[0])
self.writeAnalogOutput(4, 1, control[1])
self.writeAnalogOutput(22, 0, control[2])
self.spi.close() # XXX open and then close? what?
time.sleep(pollInterval)
except Exception as e:
logger.exception("Error running spi driver")
self.spi.close()
