def _initial(self, event):
"""Pseudostate: _initial
State machine framework initialization
"""
# Self-signaling
farc.Signal.register("_ALWAYS")
farc.Signal.register("_PHY_RQST")
# DIO Signal table (DO NOT CHANGE ORDER)
# This table is dual maintenance with phy_sx127x.PhySX127x.DIO_*
self._dio_sig_lut = (
farc.Signal.register("_DIO_MODE_RDY"),
farc.Signal.register("_DIO_CAD_DETECTED"),
farc.Signal.register("_DIO_CAD_DONE"),
farc.Signal.register("_DIO_FHSS_CHG_CHNL"),
farc.Signal.register("_DIO_RX_TMOUT"),
farc.Signal.register("_DIO_RX_DONE"),
farc.Signal.register("_DIO_CLK_OUT"),
farc.Signal.register("_DIO_PLL_LOCK"),
farc.Signal.register("_DIO_VALID_HDR"),
farc.Signal.register("_DIO_TX_DONE"),
farc.Signal.register("_DIO_PAYLD_CRC_ERR"),
)
# Self-signaling events
self._evt_always = farc.Event(farc.Signal._ALWAYS, None)
# Time events
self.tmout_evt = farc.TimeEvent("_PHY_TMOUT")
self.prdc_evt = farc.TimeEvent("_PHY_PRDC")
return self.tran(self._initializing)
def _initial(self, event):
"""PseudoState: _initial
State machine framework initialization
"""
farc.Signal.register("_UI_KEYCODE")
self._tmout_evt = farc.TimeEvent("_UI_TMOUT")
self._one_sec_evt = farc.TimeEvent("_UI_ONE_SEC")
farc.Framework.subscribe("GPS_GPRMC", self)
return self.tran(self._running)
def _initial(me, event):
"""Pseudostate: HeyMacCsmaAhsm:_initial
"""
# Incoming signals
farc.Signal.register("MAC_TX_REQ")
farc.Framework.subscribe("PHY_GPS_NMEA", me)
farc.Framework.subscribe("PHY_RXD_DATA", me)
farc.Framework.subscribe("PHY_TX_DONE", me)
# Initialize timer events
me.bcn_evt = farc.TimeEvent("_MAC_BCN_EVT_TMOUT")
me.tm_evt = farc.TimeEvent("_MAC_TM_EVT_TMOUT")
return me.tran(me, HeyMacCsmaAhsm._initializing)
def _initial(me, event):
"""Pseudostate: ChatAhsm:_initial
"""
# Incoming signals
farc.Framework.subscribe("PHY_RXD_DATA", me)
# Init a timer event
me.tm_evt = farc.TimeEvent("_APP_CHAT_TM_EVT_TMOUT")
# Init curses
stdscr = curses.initscr()
curses.noecho()
curses.cbreak()
stdscr.keypad(True)
me.stdscr = stdscr
# Init output window
y, x = stdscr.getmaxyx()
me.outwin = stdscr.subwin(y - 1, x, 0, 0)
me.outwin.idlok(True)
me.outwin.scrollok(True)
outy, outx = me.outwin.getmaxyx()
me.outwin.setscrreg(1, outy - 2)
me.outwin.border()
me.outwin.addstr(0, 4, "[ github.com/dwhall/HeyMac ]", curses.A_BOLD)
me.outwin.refresh()
# Init input window
me.inwin = stdscr.subwin(1, x, y - 1, 0)
me.inwin.scrollok(False)
me.inwin.nodelay(True)
me.inwin.refresh()
me.inmsg = bytearray()
return me.tran(me, ChatAhsm._running)
def _initial(me, event):
print("Stoplight _initial")
te = farc.TimeEvent("TIME_TICK")
te.postEvery(me, 2.0)
return me.tran(me, Stoplight._red)
def _initial(me, event):
"""Pseudostate: SX127xSpiAhsm:_initial
"""
# self-signaling
farc.Signal.register("_ALWAYS")
# Outgoing
farc.Signal.register("PHY_RXD_DATA")
farc.Signal.register("PHY_TX_DONE")
# Incoming
farc.Signal.register("PHY_STDBY")
farc.Signal.register("PHY_SET_LORA")
# Incoming from higher layer
farc.Framework.subscribe("PHY_SLEEP", me)
farc.Framework.subscribe("PHY_CAD", me)
farc.Framework.subscribe("PHY_RECEIVE", me)
farc.Framework.subscribe("PHY_TRANSMIT", me)
# Incoming from GPIO (SX127x's DIO pins)
farc.Framework.subscribe("PHY_DIO0", me)
farc.Framework.subscribe("PHY_DIO1", me)
farc.Framework.subscribe("PHY_DIO2", me)
farc.Framework.subscribe("PHY_DIO3", me)
farc.Framework.subscribe("PHY_DIO4", me)
farc.Framework.subscribe("PHY_DIO5", me)
# A time event used for setting timeouts
me.tm_evt = farc.TimeEvent("_PHY_SPI_TMOUT")
return me.tran(me, SX127xSpiAhsm._initializing)
def _initial(self, event):
print("Stoplight _initial")
te = farc.TimeEvent("TIME_TICK")
te.post_every(self, 2.0)
return self.tran(Stoplight._red)
def _initial(self, event):
"""PseudoState: _initial
State machine framework initialization
"""
# Self-signaling
farc.Signal.register("_ALWAYS")
farc.Signal.register("_LNK_RXD_FROM_PHY")
# Self-signaling events
self._evt_always = farc.Event(farc.Signal._ALWAYS, None)
# Timer events
self._bcn_evt = farc.TimeEvent("_LNK_BCN_TMOUT")
self._tm_evt = farc.TimeEvent("_LNK_TMOUT")
return self.tran(self._initializing)
def _initial(me, event):
farc.Framework.subscribe("NET_ERR", me)
farc.Framework.subscribe("NET_RXD", me)
me.tmr = farc.TimeEvent("FIVE_COUNT")
loop = asyncio.get_event_loop()
server = loop.create_datagram_endpoint(UdpServer,
local_addr=("localhost",
UDP_PORT))
me.transport, me.protocol = loop.run_until_complete(server)
return me.tran(me, UdpRelayAhsm._waiting)
def _initial(self, event):
"""Pseudostate: UartHsm:_initial"""
farc.Signal.register("_UART_OPEN")
farc.Signal.register("_UART_CLOSE")
self._open_evt = farc.Event(farc.Signal._UART_OPEN, None)
self._close_evt = farc.Event(farc.Signal._UART_CLOSE, None)
self._tm_evt = farc.TimeEvent("_UART_TMOUT")
return self.tran(UartHsm._ready)
def _initial(me, event):
"""Pseudostate: UartAhsm:_initial
"""
# Incoming signals
farc.Signal.register(
"PHY_UART_OPEN") # Value is serial.Serial() parameters
farc.Signal.register("PHY_UART_CLOSE") # No value
# Initialize a timer to perform polling
me.tm_evt = farc.TimeEvent("_PHY_UART_TM_EVT")
return me.tran(me, UartAhsm._ready)
def _initial(me, event):
"""Pseudostate: HeyMacAhsm:_initial
"""
# Incoming signals
farc.Signal.register("MAC_TX_REQ")
farc.Framework.subscribe("PHY_GPS_PPS", me)
farc.Framework.subscribe("PHY_RXD_DATA", me)
farc.Framework.subscribe("PHY_GPS_NMEA", me)
# Initialize a timer event
me.tm_evt = farc.TimeEvent("_MAC_TDMA_TM_EVT_TMOUT")
# Calculate the 128-bit source address from the identity's pub_key
h = hashlib.sha512()
h.update(mac_identity['pub_key'])
h.update(h.digest())
me.saddr = h.digest()[:8]
assert me.saddr[0] in (0xfc, 0xfd)
# Init HeyMac values
me.asn = 0
me.sf_order = mac_tdma_cfg.FRAME_SPEC_SF_ORDER
me.eb_order = mac_tdma_cfg.FRAME_SPEC_EB_ORDER
me.dscpln = mac_tdma_discipline.HeyMacDiscipline()
# Data Link Layer data
# TODO: network's SF/EB_ORDER values may change at runtime.
# Need to have mac_data's ValidatedDicts adapt.
tm_tslot_period = (1.0 / mac_tdma_cfg.TSLOTS_PER_SEC)
tm_sf_period = (2**mac_tdma_cfg.FRAME_SPEC_SF_ORDER) * tm_tslot_period
tm_eb_period = (2**mac_tdma_cfg.FRAME_SPEC_EB_ORDER) * tm_sf_period
bcn_expiration = 4 * tm_sf_period
ebcn_expiration = 2 * tm_eb_period
me.mac_data = mac_data.MacData(bcn_expiration, ebcn_expiration)
# Transmit queue
me.mac_txq = []
return me.tran(me, HeyMacAhsm._initializing)
def _initial(me, event):
print("_initial")
me.te = farc.TimeEvent("TIME_TICK")
return me.tran(me, Countdown._counting)
def _initial(self, event):
print("_initial")
self.teCount = farc.TimeEvent("COUNT")
self.tePrint = farc.TimeEvent("PRINT")
return self.tran(Mississippi._counting)
def _initial(self, event):
print("Three _initial")
self.te = farc.TimeEvent("TICK3")
return self.tran(Three._running)
def _initial(me, event):
print("Five _initial")
me.te = farc.TimeEvent("TICK5")
return me.tran(me, Five._running)
def _initial(self, event):
print("_initial")
self.te = farc.TimeEvent("TIME_TICK")
return self.tran(Countdown._counting)
def _initial(me, event):
print("_initial")
me.teCount = farc.TimeEvent("COUNT")
me.tePrint = farc.TimeEvent("PRINT")
return me.tran(me, Mississippi._counting)
def _initial(me, event):
print("Three _initial")
me.te = farc.TimeEvent("TICK3")
return me.tran(me, Three._running)
def _initial(self, event):
self.timeEvt = farc.TimeEvent("TIMEOUT")
farc.Framework.subscribe("EAT", self)
return self.tran(Philo._thinking)
def _initial(self, event):
print("Five _initial")
self.te = farc.TimeEvent("TICK5")
return self.tran(Five._running)
