def _generate_struct_from_headers(
self, header_tables): # type: (Container) -> Struct
"""
Generate ``construct`` Struct for this file
:param header_tables: contains elf_header, program_headers, section_headers
:return: Struct of the whole file
"""
elf_header = header_tables.elf_header
program_headers = header_tables.program_headers
section_headers = header_tables.section_headers
assert program_headers or section_headers
string_table_sh = None
load_segment_subcons = []
note_segment_subcons = []
# Here we point back to make segments know their program headers
for i, ph in enumerate(program_headers):
args = [
'ph' / Pointer(elf_header.e_phoff + i * ProgramHeader.sizeof(),
ProgramHeader),
'data' / Pointer(ph.p_offset, Bytes(ph.p_filesz)),
]
if ph.p_vaddr == 0 and ph.p_type == self.PT_NOTE:
args.append('note_secs' / Pointer(ph.p_offset, NoteSections))
note_segment_subcons.append(Struct(*args))
elif ph.p_vaddr != 0:
load_segment_subcons.append(Struct(*args))
section_subcons = []
for i, sh in enumerate(section_headers):
if sh.sh_type == self.SHT_STRTAB and i == elf_header.e_shstrndx:
string_table_sh = sh
elif sh.sh_addr != 0 and sh.sh_type == self.SHT_PROGBITS:
section_subcons.append(
Struct(
'sh' / Pointer(
elf_header.e_shoff + i * SectionHeader.sizeof(),
SectionHeader),
'data' / Pointer(sh.sh_offset, Bytes(sh.sh_size)),
))
args = [
'elf_header' / ElfHeader,
'load_segments' / Sequence(*load_segment_subcons),
'note_segments' / Sequence(*note_segment_subcons),
'sections' / Sequence(*section_subcons),
]
if string_table_sh is not None:
args.append('string_table' / Pointer(
string_table_sh.sh_offset, Bytes(string_table_sh.sh_size)))
return Struct(*args)
def _RangeForm(self, element):
return Embedded(
Sequence(
'MinimumValue' / element,
'MaximumValue' / element,
'StepSize' / element,
))
def PascalUtf16(size_type=Int16ul):
"""Parse a length-defined string in UTF-16."""
return _Utf16(Sequence(
size_type,
Bytes(this[0] * 2),
))
def DelimitedField(stop):
return _StripDelimiter(
Sequence(
RepeatUntil(
lambda x, lst, ctx: lst[-len(stop):] == [int(c) for c in stop],
Byte), Computed(this[0][:-len(stop)]),
Seek(-len(stop), whence=1)))
def AlphaString(name):
return StringAdapter(
DoubleAdapter(
Sequence(
name,
UBInt16("length"),
MetaField("data", lambda ctx: ctx["length"] * 2),
)),
encoding="ucs2",
)
class DemoConfigStruct(ConfStructure):
# The structures of value in the following fields are equal.
val1 = ConstructorField(code=0x01, constructor=Short)
val2 = SingleField(code=0x02, format='>H')
# The structures of value in the following fields are equal.
ip1 = ConstructorField(code=0x03,
constructor=ServerAddressAdapter(Byte[6]))
ip2 = ConstructorField(code=0x04, constructor=ServerAddressStruct())
pos1 = ConstructorField(code=0x05, constructor=Sequence(Byte, Byte))
def BigInteger(length_field):
def decode_big(obj, _ctx):
(_length, isNegative, value) = obj
ret = sum([d << i*8 for (d, i) in zip(value, range(0, len(value)))])
if isNegative:
return -ret
return ret
def encode_big(obj, _ctx):
isNegative = 0
if obj < 0:
isNegative = 1
obj = -obj
value = []
while obj > 0:
value.append(obj & 0xFF)
obj = obj >> 8
return (len(value), isNegative, value)
return ExprAdapter(Sequence("len" / length_field,
"isNegative" / Int8ub,
"value" / Array(lambda ctx: ctx.len, Int8ub)),
encoder=encode_big,
decoder=decode_big)
from empower.core.module import Module
from empower.core.module import ModuleLVAPPWorker
from empower.main import RUNTIME
PT_ADD_SUMMARY = 0x22
PT_SUMMARY = 0x23
PT_DEL_SUMMARY = 0x24
ADD_SUMMARY = Struct("add_summary", UBInt8("version"), UBInt8("type"),
UBInt16("length"), UBInt32("seq"), UBInt32("module_id"),
Bytes("addrs", 6), Bytes("hwaddr", 6), UBInt8("channel"),
UBInt8("band"), SBInt16("limit"), UBInt16("period"))
SUMMARY_ENTRY = Sequence("frames", Bytes("addr", 6), UBInt64("tsft"),
UBInt16("seq"), SBInt8("rssi"), UBInt8("rate"),
UBInt8("type"), UBInt8("subtype"), UBInt32("length"))
SUMMARY_TRIGGER = Struct("summary", UBInt8("version"), UBInt8("type"),
UBInt16("length"), UBInt32("seq"),
UBInt32("module_id"), Bytes("wtp", 6),
UBInt16("nb_entries"),
Array(lambda ctx: ctx.nb_entries, SUMMARY_ENTRY))
DEL_SUMMARY = Struct("del_summary", UBInt8("version"), UBInt8("type"),
UBInt16("length"), UBInt32("seq"), UBInt32("module_id"))
class Summary(Module):
""" Summary object. """
ConstructResourceDatabase = Struct(
items=PrefixedArray(Byte, ConstructResourceInfo),
events=PrefixedArray(Byte, ConstructResourceInfo),
tricks=PrefixedArray(Byte, ConstructResourceInfo),
damage=PrefixedArray(Byte, Struct(
Embedded(ConstructResourceInfo),
reductions=PrefixedArray(Byte, Struct(
index=Byte,
multiplier=Float32b,
)),
)),
versions=PrefixedArray(Byte, ConstructResourceInfo),
misc=PrefixedArray(Byte, ConstructResourceInfo),
difficulty=PrefixedArray(Byte, ConstructResourceInfo),
requirement_template=PrefixedArray(VarInt, Sequence(CString("utf8"), ConstructRequirement))
)
ConstructEchoesBeamConfiguration = Struct(
item_index=Byte,
_has_ammo_a=Rebuild(Flag, lambda this: this.ammo_a is not None),
ammo_a=If(lambda this: this._has_ammo_a, Byte),
_has_ammo_b=Rebuild(Flag, lambda this: this.ammo_b is not None),
ammo_b=If(lambda this: this._has_ammo_b, Byte),
uncharged_cost=Byte,
charged_cost=Byte,
combo_missile_cost=Byte,
combo_ammo_cost=Byte,
)
ConstructEchoesGameSpecific = Struct(
from construct import UBInt16
from construct import UBInt32
from construct import Array
from empower.datatypes.etheraddress import EtherAddress
from empower.lvapp.lvappserver import ModuleLVAPPWorker
from empower.core.module import Module
from empower.core.app import EmpowerApp
from empower.lvapp import PT_VERSION
from empower.main import RUNTIME
PT_STATS_REQUEST = 0x17
PT_STATS_RESPONSE = 0x18
STATS = Sequence("stats", UBInt16("bytes"), UBInt32("count"))
STATS_REQUEST = Struct("stats_request", UBInt8("version"), UBInt8("type"),
UBInt32("length"), UBInt32("seq"), UBInt32("module_id"),
Bytes("sta", 6))
STATS_RESPONSE = \
Struct("stats_response", UBInt8("version"),
UBInt8("type"),
UBInt32("length"),
UBInt32("seq"),
UBInt32("module_id"),
Bytes("wtp", 6),
Bytes("sta", 6),
UBInt16("nb_tx"),
UBInt16("nb_rx"),
from construct import Array
from empower.lvapp import PT_VERSION
from empower.datatypes.etheraddress import EtherAddress
from empower.lvapp.lvappserver import LVAPPServer
from empower.datatypes.etheraddress import EtherAddress
from empower.lvapp.lvappserver import ModuleLVAPPWorker
from empower.core.module import Module
from empower.core.app import EmpowerApp
from empower.main import RUNTIME
PT_CQM_LINKS_REQUEST = 0x43
PT_CQM_LINKS_RESPONSE = 0x44
CQM_LINK = Sequence("stats", Bytes("ta", 6), UBInt32("p_pdf"),
UBInt32("p_available_bw"))
CQM_LINKS_REQUEST = Struct("stats_request", UBInt8("version"), UBInt8("type"),
UBInt32("length"), UBInt32("seq"),
UBInt32("module_id"))
CQM_LINKS_RESPONSE = \
Struct("stats_response", UBInt8("version"),
UBInt8("type"),
UBInt32("length"),
UBInt32("seq"),
UBInt32("module_id"),
Bytes("wtp", 6),
UBInt16("nb_links"),
Array(lambda ctx: ctx.nb_links, CQM_LINK))
Bit("authenticated")), UBInt16("assoc_id"), Bytes("hwaddr", 6),
UBInt8("channel"), UBInt8("band"), Bytes("sta", 6), Bytes("encap", 6),
Bytes("net_bssid", 6), Bytes("lvap_bssid", 6), SSIDS)
DEL_LVAP = Struct("del_lvap", UBInt8("version"), UBInt8("type"),
UBInt16("length"), UBInt32("seq"), Bytes("sta", 6))
STATUS_LVAP = Struct(
"status_lvap", UBInt8("version"), UBInt8("type"), UBInt16("length"),
UBInt32("seq"),
BitStruct("flags", Padding(13), Bit("set_mask"), Bit("associated"),
Bit("authenticated")), UBInt16("assoc_id"), Bytes("wtp", 6),
Bytes("sta", 6), Bytes("encap", 6), Bytes("hwaddr", 6), UBInt8("channel"),
UBInt8("band"), Bytes("net_bssid", 6), Bytes("lvap_bssid", 6), SSIDS)
CAPS_R = Sequence("blocks", Bytes("hwaddr", 6), UBInt8("channel"),
UBInt8("band"), BitStruct("flags", Padding(16)))
CAPS_P = Sequence("ports", Bytes("hwaddr", 6), UBInt16("port_id"),
Bytes("iface", 10))
CAPS = Struct("caps", UBInt8("version"), UBInt8("type"), UBInt16("length"),
UBInt32("seq"), Bytes("wtp", 6), UBInt8("nb_resources_elements"),
UBInt8("nb_ports_elements"),
Array(lambda ctx: ctx.nb_resources_elements, CAPS_R),
Array(lambda ctx: ctx.nb_ports_elements, CAPS_P))
SET_PORT = Struct("set_port", UBInt8("version"), UBInt8("type"),
UBInt16("length"), UBInt32("seq"),
BitStruct("flags", Padding(15), Bit("no_ack")),
Bytes("hwaddr", 6), UBInt8("channel"), UBInt8("band"),
Bytes("sta", 6), UBInt16("rts_cts"), UBInt8("tx_mcast"),
from construct import Bit
from empower.core.resourcepool import BT_L20
from empower.core.app import EmpowerApp
from empower.datatypes.etheraddress import EtherAddress
from empower.lvapp.lvappserver import ModuleLVAPPWorker
from empower.core.module import ModulePeriodic
from empower.lvapp import PT_VERSION
from empower.main import RUNTIME
PT_RATES_REQUEST = 0x30
PT_RATES_RESPONSE = 0x31
RATES_ENTRY = Sequence("rates", UBInt8("rate"),
BitStruct("flags", Padding(6), Bit("mcs"), Padding(9)),
UBInt32("prob"), UBInt32("cur_prob"))
RATES_REQUEST = Struct("rates_request", UBInt8("version"), UBInt8("type"),
UBInt32("length"), UBInt32("seq"), UBInt32("module_id"),
Bytes("sta", 6))
RATES_RESPONSE = Struct("rates_response", UBInt8("version"), UBInt8("type"),
UBInt32("length"), UBInt32("seq"),
UBInt32("module_id"), Bytes("wtp", 6),
UBInt16("nb_entries"),
Array(lambda ctx: ctx.nb_entries, RATES_ENTRY))
class LVAPStats(ModulePeriodic):
""" LVAPStats object. """
Footer = Struct(
Const(b'\xf7'), # SysEx End
)
Header_Mk2 = Struct(
'mk2' / Computed(True),
Const(b'\xf0'), # SysEx Begin
Const(b'\x47\x00'), # Mfg ID = Akai
Const(b'\x26'), # Dev ID = MPK Mk2
Const(b'\x64'), # CMD = Dump (67) / Load (64) Preset
Const(b'\x00\x6d'), # Len = 109bytes (7bit stuffed)
Embedded(General), # Note: different order to Mk1
Embedded(Arpeggio_enable),
Embedded(Arpeggio_mode),
Embedded(Arpeggio_div),
Embedded(Arpeggio_clk),
Embedded(Arpeggio),
Embedded(Joy),
)
MPK_MINI_MK2 = Sequence(
Header_Mk2,
Array(_PBANKS, Array(_PADS, Pad,)),
Array(_DBANKS, Array(_DIALS, Dial,)),
Transpose,
Footer,
)
pattern = re.compile("<START>.*?<END>")
total_lines = get_total_lines(str(base_file_location / 'formatted.txt'))
db_train = {}
db_test = {}
with open(str(base_file_location / 'formatted.txt'), 'r',
encoding='utf-8') as file:
index = 0 # cheap tricks to store correct and changed sentence one after the other
start_from_pos = 0 # while ensuring there is a 80-20 train-test split.
for i, line in tqdm(enumerate(file)):
sample = None
if i % 2 == 0:
sample = Grammar(line)
else:
sample = Sequence(line)
if min_length_qualify(sample.correct):
sample.make_change()
correct, changed = sample.correct, sample.changed
correct_label, changed_label = labelify(
correct, changed, i, sample.change_type)
a = Type1Label(correct, correct_label, convert_to_max=True)
# a.pretty_print()
b = Type1Label(changed, changed_label, convert_to_max=True)
# b.pretty_print()
if index < int(0.4 * total_lines):
db_test[index] = a.store_dict()
TileIdEntry = Struct(
"type" / PascalString(Int8ul, "latin-1"),
"names" / PrefixedArray(
Int8ul,
Struct(
"name" / PascalString(Int8ul, "latin-1"),
"id" / Int8ul,
)),
)
achievement_types = {
'achievement': Computed(lambda this: "no-data"),
'build-entity-achievement': Int32ul,
'combat-robot-count': Int32ul,
'construct-with-robots-achievement': Sequence(Int32ul, Int32ul),
'deconstruct-with-robots-achievement': Int32ul,
'deliver-by-robots-achievement': Float64l,
'dont-build-entity-achievement': Int32ul,
#'dont-craft-manually-achievement': Unknown
'dont-use-entity-in-energy-production-achievement': Float64l,
'finish-the-game-achievement': Int32ul,
'group-attack-achievement': Int32ul,
'kill-achievement': Float64l,
'player-damaged-achievement': Sequence(Float32l, Int8ul),
'produce-achievement': Float64l,
'produce-per-hour-achievement': Float64l,
'research-achievement': Computed(lambda this: "no-data"),
'train-path-achievement': Float64l,
}
from construct import Array
from empower.core.lvap import LVAP
from empower.datatypes.etheraddress import EtherAddress
from empower.core.module import ModuleLVAPPWorker
from empower.core.module import Module
from empower.lvapp import PT_VERSION
from empower.main import RUNTIME
PT_RATES_REQUEST = 0x29
PT_RATES_RESPONSE = 0x30
RATES_ENTRY = Sequence("rates",
UBInt8("rate"),
UBInt8("prob"))
RATES_REQUEST = Struct("rates_request", UBInt8("version"),
UBInt8("type"),
UBInt16("length"),
UBInt32("seq"),
UBInt32("module_id"),
Bytes("sta", 6))
RATES_RESPONSE = Struct("rates_response", UBInt8("version"),
UBInt8("type"),
UBInt16("length"),
UBInt32("seq"),
UBInt32("module_id"),
# but len(entry_enabled)==16 while len(revidx)<=16 FirstReverseIndexArray = Struct( "entries" / Array(this._._.entry_count%16, ReverseIndexedEntry), "entry_enabled" / ByteSwapped(Bitwise(Array(16, Flag))), # may start with unexistant entries, see above! "entry_enabled_override" / ByteSwapped(Bitwise(Array(16, Flag))) # may start with unexistant entries, see above! ) FullReverseIndexArray = Struct( "entries" / Array(16, ReverseIndexedEntry), "entry_enabled" / ByteSwapped(Bitwise(Array(16, Flag))), "entry_enabled_override" / ByteSwapped(Bitwise(Array(16, Flag))) ) PageEndHeader = Sequence( FirstReverseIndexArray, Embedded(Array(this._.entry_count//16, FullReverseIndexArray)) ) PageHeader = Struct( # 40 bytes Padding(4), # always 0 "index" / Int32ul, # in units of 4096 bytes "page_type" / PageTypeEnum, "next_index" / Int32ul, # in units of 4096 bytes, finally points to empty page, even outside of file "u1" / Int32ul, # sequence number (0->1: 8->13, 1->2: 22, 2->3: 27) Padding(4), "real_entry_count" / Int8ul, "u3" / Int8ul, # a bitmask (1st track: 32) "u4" / Int16ul, # 25600 for strange blocks "free_size" / Int16ul, # excluding data at page end "payload_size" / Int16ul, "u7" / Int16ul, # (0->1: 2)
from empower.core.resourcepool import BT_L20
from empower.core.app import EmpowerApp
from empower.datatypes.etheraddress import EtherAddress
from empower.lvapp.lvappserver import ModuleLVAPPWorker
from empower.core.module import ModulePeriodic
from empower.lvapp import PT_VERSION
from empower.main import RUNTIME
PT_NIF_REQUEST = 0x90
PT_NIF_RESPONSE = 0x91
NIF_STATS_ENTRY = Sequence(
"rates", UBInt8("rate"),
BitStruct("flags", Padding(6), Bit("mcs"), Padding(9)), UBInt32("prob"),
UBInt32("cur_prob"), UBInt64("hist_successes"), UBInt64("hist_attempts"),
UBInt32("last_successes"), UBInt32("last_attempts"),
UBInt64("last_acked_bytes"), UBInt64("hist_acked_bytes"))
NIF_STATS_REQUEST = Struct("nif_request", UBInt8("version"), UBInt8("type"),
UBInt32("length"), UBInt32("seq"),
UBInt32("module_id"), Bytes("sta", 6))
NIF_STATS_RESPONSE = Struct("nif_response", UBInt8("version"), UBInt8("type"),
UBInt32("length"), UBInt32("seq"),
UBInt32("module_id"), Bytes("wtp", 6),
UBInt16("nb_entries"),
Array(lambda ctx: ctx.nb_entries, NIF_STATS_ENTRY))
class NIFStats(ModulePeriodic):
from empower.lvapp import PT_VERSION
from empower.datatypes.etheraddress import EtherAddress
from empower.lvapp.lvappserver import LVAPPServer
from empower.datatypes.etheraddress import EtherAddress
from empower.lvapp.lvappserver import ModuleLVAPPWorker
from empower.core.module import Module
from empower.core.app import EmpowerApp
from empower.main import RUNTIME
PT_CQM_LINKS_REQUEST = 0x43
PT_CQM_LINKS_RESPONSE = 0x44
CQM_LINK = Sequence("stats", Bytes("ta",
6), UBInt32("p_channel_busy_fraction"),
UBInt32("p_throughput"), UBInt32("p_available_bw"),
UBInt32("p_pdf"), UBInt32("p_attainable_throughput"))
CQM_LINKS_REQUEST = Struct("stats_request", UBInt8("version"), UBInt8("type"),
UBInt32("length"), UBInt32("seq"),
UBInt32("module_id"))
CQM_LINKS_RESPONSE = \
Struct("stats_response", UBInt8("version"),
UBInt8("type"),
UBInt32("length"),
UBInt32("seq"),
UBInt32("module_id"),
Bytes("wtp", 6),
UBInt16("nb_links"),
Array(lambda ctx: ctx.nb_links, CQM_LINK))
)
anchor = Struct(
Const(b"\xff" * 4),
"akttab" / blockref,
"clorX" / blockref,
Const(b"\xff" * 4 * 3),
"taskRoot" / blockref,
Const(b"\xff" * 4),
) * "System anchor block"
assert pagesize // blockref.sizeof() == 128
blockTable = Array(pagesize // blockref.sizeof(), blockref)
# XXX: skip const
segmentTable = Sequence(Const(2 * blockref.sizeof() * b'\xff'),
Array(14, blockref))
drinfo = Struct(
"count" / blockref * "Number of blocks/pages allocated",
"blocks" / Array(3, blockref) *
"Direct block references for page 1, 2 and 3",
"blockTables" / Array(2, blockref) * "Block references to block tables",
"segmentTables" / Array(2, blockref) *
"Block references to segment tables, which refer to block tables",
) * "Dataspace descriptor"
# see src/devel/misc/unknown/src/XSTATUS.ELA
# EUMEL’s pcb function returns the 16 bit word at position (0x1e+2*<id>)%0x40
# i.e. module is pcb(23) → at offset 0x0c
pcb = Struct(
"wstate" / Int32ul,
DEL_LVAP = Struct("del_lvap", UBInt8("version"), UBInt8("type"),
UBInt32("length"), UBInt32("seq"), UBInt32("module_id"),
Bytes("sta", 6), Bytes("target_hwaddr", 6),
UBInt8("target_channel"), UBInt8("tagert_band"),
UBInt8("csa_switch_mode"), UBInt8("csa_switch_count"))
STATUS_LVAP = Struct(
"status_lvap", UBInt8("version"), UBInt8("type"), UBInt32("length"),
UBInt32("seq"),
BitStruct("flags", Padding(13), Bit("set_mask"), Bit("associated"),
Bit("authenticated")), UBInt16("assoc_id"), Bytes("wtp", 6),
Bytes("sta", 6), Bytes("encap", 6), Bytes("hwaddr", 6), UBInt8("channel"),
UBInt8("band"), UBInt8("supported_band"), Bytes("net_bssid", 6),
Bytes("lvap_bssid", 6), SSIDS)
CAPS_R = Sequence("blocks", Bytes("hwaddr", 6), UBInt8("channel"),
UBInt8("band"))
CAPS_P = Sequence("ports", Bytes("hwaddr", 6), UBInt16("port_id"),
Bytes("iface", 10))
CAPS_RESPONSE = Struct("caps", UBInt8("version"), UBInt8("type"),
UBInt32("length"), UBInt32("seq"), Bytes("wtp", 6),
UBInt8("nb_resources_elements"),
UBInt8("nb_ports_elements"),
Array(lambda ctx: ctx.nb_resources_elements, CAPS_R),
Array(lambda ctx: ctx.nb_ports_elements, CAPS_P))
CAPS_REQUEST = Struct("caps_request", UBInt8("version"), UBInt8("type"),
UBInt32("length"), UBInt32("seq"))
LVAP_STATUS_REQUEST = Struct("lvap_status_request", UBInt8("version"),
events=PrefixedArray(VarInt, ConstructResourceInfo),
tricks=PrefixedArray(VarInt, ConstructTrickResourceInfo),
damage=PrefixedArray(
VarInt,
Struct(
Embedded(ConstructResourceInfo),
reductions=PrefixedArray(
VarInt, Struct(
index=VarInt,
multiplier=Float32b,
)),
)),
versions=PrefixedArray(VarInt, ConstructResourceInfo),
misc=PrefixedArray(VarInt, ConstructResourceInfo),
requirement_template=PrefixedArray(
VarInt, Sequence(CString("utf8"), ConstructRequirement)))
ConstructEchoesBeamConfiguration = Struct(
item_index=VarInt,
ammo_a=OptionalValue(Byte),
ammo_b=OptionalValue(Byte),
uncharged_cost=Byte,
charged_cost=Byte,
combo_missile_cost=Byte,
combo_ammo_cost=Byte,
)
ConstructEchoesGameSpecific = Struct(
energy_per_tank=Float32b,
safe_zone_heal_per_second=Float32b,
beam_configurations=PrefixedArray(VarInt,
from empower.core.resourcepool import CQM
from empower.core.resourcepool import ResourceBlock
from empower.core.resourcepool import ResourcePool
from empower.core.module import Module
from empower.lvapp import PT_VERSION
from empower.main import RUNTIME
PT_POLLER_REQ_MSG_TYPE = 0x27
PT_POLLER_RESP_MSG_TYPE = 0x28
POLLER_ENTRY_TYPE = Sequence("img_entries",
Bytes("addr", 6),
UBInt32("last_rssi_std"),
SBInt32("last_rssi_avg"),
UBInt32("last_packets"),
UBInt32("hist_packets"),
SBInt32("ewma_rssi"),
SBInt32("sma_rssi"))
POLLER_REQUEST = Struct("poller_request", UBInt8("version"),
UBInt8("type"),
UBInt16("length"),
UBInt32("seq"),
UBInt32("module_id"),
Bytes("addrs", 6),
Bytes("hwaddr", 6),
UBInt8("channel"),
UBInt8("band"))
POLLER_RESPONSE = Struct("poller_response", UBInt8("version"),
return mapping[obj.__class__]
# Recurrent term
term_ = LazyBound(lambda: term)
atom_cache_ref = ExprAdapter(Int8ub,
encoder=lambda obj, ctx: obj.index,
decoder=lambda obj, ctx: AtomCacheReference(obj))
small_integer = Int8ub
integer = Int32sb
float_ = ExprAdapter(PaddedString(31, encoding="ascii"),
encoder=lambda obj, ctx: u"{:.20e} ".format(obj),
decoder=lambda obj, ctx: float(obj))
atom = PascalString(lengthfield=Int16ub, encoding="latin1")
reference = ExprAdapter(Sequence("node" / term_,
"id" / Int32ub,
"creation" / Int8ub),
encoder=lambda obj, ctx: (obj.node, obj.id, obj.creation),
decoder=lambda obj, ctx: Reference(*obj))
port = ExprAdapter(Sequence("node" / term_,
"id" / Int32ub,
"creation" / Int8ub),
encoder=lambda obj, ctx: (obj.node, obj.id, obj.creation),
decoder=lambda obj, ctx: Port(*obj))
pid = ExprAdapter(Sequence("node" / term_,
"id" / Int32ub,
"serial" / Int32ub,
"creation" / Int8ub),
encoder=lambda obj, ctx: (obj.node, obj.id, obj.serial, obj.creation),
decoder=lambda obj, ctx: Pid(*obj))
small_tuple = TupleAdapter(PrefixedArray(Int8ub, term_))
},
}
# Constants
BYTE_N = 16
SAMPLING_BASE_TIME = timedelta(0, 0, 1000000)
# Structure for data exchange with sockets
MyDataFormat = Struct(
"Signature" / Const(b"BMS"),
"time" / Int32ub,
"data" / Array(BYTE_N, Int16ub),
)
# Structure for data exchange with sockets PL1012 Picolog
PL1012BYTE_N = 12
PL1012DataFormat = Struct("data" / Array(PL1012BYTE_N, Int16ul))
TC08FLOAT_N = 9
TC08DataFormat = Struct("data" / Array(TC08FLOAT_N, Float32l))
PEAK_MSGS = 6
CANREAD_TIMEOUT = 0.600000
PEAKDataFormat = Array(PEAK_MSGS,
Sequence(PaddedString(11, 'utf-8'), Array(8, Int8ub)))
# Screen position of data
SCREEN_POS = [(5, 2), (7, 2), (9, 2), (11, 2), (13, 2), (15, 2), (17, 2),
(19, 2), (21, 2), (23, 2), (5, 27), (7, 27), (9, 27), (11, 27),
(13, 27), (15, 27), (17, 27), (19, 27), (21, 27), (23, 27),
(5, 52), (7, 52), (9, 52), (11, 52),
(13, 52), (15, 52), (17, 52), (19, 52), (21, 52), (23, 52),
(5, 77), (7, 77), (9, 77), (11, 77), (13, 77), (15, 77),
(17, 77), (19, 77), (21, 77), (23, 77), (25, 2)]
UBInt32("seq"),
UBInt32("module_id"),
Bytes("addr", 6),
Bytes("hwaddr", 6),
UBInt8("channel"),
UBInt8("band"),
SBInt16("limit"),
UBInt16("period"))
SUMMARY_ENTRY = Sequence("frames",
Bytes("ra", 6),
Bytes("ta", 6),
UBInt64("tsft"),
BitStruct("flags",
Padding(6),
Bit("mcs"),
Padding(9)),
UBInt16("seq"),
SBInt8("rssi"),
UBInt8("rate"),
UBInt8("type"),
UBInt8("subtype"),
UBInt32("length"))
SUMMARY_TRIGGER = Struct("summary", UBInt8("version"),
UBInt8("type"),
UBInt32("length"),
UBInt32("seq"),
UBInt32("module_id"),
Bytes("wtp", 6),
UBInt16("nb_entries"),
Array(lambda ctx: ctx.nb_entries, SUMMARY_ENTRY))
from empower.lvapp import PT_VERSION
from empower.datatypes.etheraddress import EtherAddress
from empower.lvapp.lvappserver import LVAPPServer
from empower.datatypes.etheraddress import EtherAddress
from empower.lvapp.lvappserver import ModuleLVAPPWorker
from empower.core.module import Module
from empower.core.app import EmpowerApp
from empower.main import RUNTIME
PT_WTP_STATS_REQUEST = 0x41
PT_WTP_STATS_RESPONSE = 0x42
WTP_STATS = Sequence("stats",
Bytes("lvap", 6),
UBInt16("bytes"),
UBInt32("count"))
WTP_STATS_REQUEST = Struct("stats_request", UBInt8("version"),
UBInt8("type"),
UBInt32("length"),
UBInt32("seq"),
UBInt32("module_id"))
WTP_STATS_RESPONSE = \
Struct("stats_response", UBInt8("version"),
UBInt8("type"),
UBInt32("length"),
UBInt32("seq"),
UBInt32("module_id"),
Bytes("wtp", 6),
from construct import Array
from empower.lvapp.lvappserver import ModuleLVAPPWorker
from empower.core.app import EmpowerApp
from empower.datatypes.etheraddress import EtherAddress
from empower.core.module import ModulePeriodic
from empower.core.resourcepool import CQM
from empower.core.resourcepool import ResourceBlock
from empower.lvapp import PT_VERSION
from empower.main import RUNTIME
PT_WIFI_STATS_REQUEST = 0x37
PT_WIFI_STATS_RESPONSE = 0x38
ENTRY_TYPE = Sequence("entries", UBInt8("type"), UBInt32("timestamp"),
UBInt32("sample"))
WIFI_STATS_REQUEST = Struct("wifi_stats_request", UBInt8("version"),
UBInt8("type"), UBInt32("length"), UBInt32("seq"),
UBInt32("module_id"), Bytes("hwaddr", 6),
UBInt8("channel"), UBInt8("band"))
WIFI_STATS_RESPONSE = Struct("wifi_stats_response", UBInt8("version"),
UBInt8("type"), UBInt32("length"), UBInt32("seq"),
UBInt32("module_id"), Bytes("wtp", 6),
UBInt16("nb_entries"),
Array(lambda ctx: ctx.nb_entries, ENTRY_TYPE))
class WiFiStats(ModulePeriodic):
""" A maps poller. """
