"""
Convert data length to radio TX/RX energy.
Contains classes for some embedded CPUs/MCUs. Given a configuration, each
class can convert a cycle count to an energy consumption.
"""
import numpy as np
def get_class(radio_name: str):
"""Return model class for radio_name."""
if radio_name == "CC1200tx":
return CC1200tx
if radio_name == "CC1200rx":
return CC1200rx
if radio_name == "NRF24L01tx":
return NRF24L01tx
if radio_name == "NRF24L01dtx":
return NRF24L01dtx
if radio_name == "esp8266dtx":
return ESP8266dtx
if radio_name == "esp8266drx":
return ESP8266drx
def _param_list_to_dict(device, param_list):
param_dict = dict()
for i, parameter in enumerate(sorted(device.parameters.keys())):
param_dict[parameter] = param_list[i]
return param_dict
class CC1200tx:
"""CC1200 TX energy based on aemr measurements."""
name = "CC1200tx"
parameters = {
"symbolrate": [6, 12, 25, 50, 100, 200, 250], # ksps
"txbytes": [],
"txpower": [10, 20, 30, 40, 47], # dBm = f(txpower)
}
default_params = {"symbolrate": 100, "txpower": 47}
@staticmethod
def get_energy(params: dict):
if type(params) != dict:
return CC1200tx.get_energy(_param_list_to_dict(CC1200tx, params))
# Mittlere TX-Leistung, gefitted von AEMR
# Messdaten erhoben bei 3.6V
power = 8.18053941e04
power -= 1.24208376e03 * np.sqrt(params["symbolrate"])
power -= 5.73742779e02 * np.log(params["txbytes"])
power += 1.76945886e01 * (params["txpower"]) ** 2
power += (
2.33469617e02 * np.sqrt(params["symbolrate"]) * np.log(params["txbytes"])
)
power -= (
6.99137635e-01 * np.sqrt(params["symbolrate"]) * (params["txpower"]) ** 2
)
power -= 3.31365158e-01 * np.log(params["txbytes"]) * (params["txpower"]) ** 2
power += (
1.32784945e-01
* np.sqrt(params["symbolrate"])
* np.log(params["txbytes"])
* (params["txpower"]) ** 2
)
# txDone-Timeout, gefitted von AEMR
duration = 3.65513500e02
duration += 8.01016526e04 * 1 / (params["symbolrate"])
duration -= 7.06364515e-03 * params["txbytes"]
duration += 8.00029860e03 * 1 / (params["symbolrate"]) * params["txbytes"]
# TX-Energie, gefitted von AEMR
# Achtung: Energy ist in µJ, nicht (wie in AEMR-Transitionsmodellen üblich) in pJ
# Messdaten erhoben bei 3.6V
energy = 1.74383259e01
energy += 6.29922138e03 * 1 / (params["symbolrate"])
energy += 1.13307135e-02 * params["txbytes"]
energy -= 1.28121377e-04 * (params["txpower"]) ** 2
energy += 6.29080184e02 * 1 / (params["symbolrate"]) * params["txbytes"]
energy += 1.25647926e00 * 1 / (params["symbolrate"]) * (params["txpower"]) ** 2
energy += 1.31996202e-05 * params["txbytes"] * (params["txpower"]) ** 2
energy += (
1.25676966e-01
* 1
/ (params["symbolrate"])
* params["txbytes"]
* (params["txpower"]) ** 2
)
return energy * 1e-6
@staticmethod
def get_energy_per_byte(params):
A = 8.18053941e04
A -= 1.24208376e03 * np.sqrt(params["symbolrate"])
A += 1.76945886e01 * (params["txpower"]) ** 2
A -= 6.99137635e-01 * np.sqrt(params["symbolrate"]) * (params["txpower"]) ** 2
B = -5.73742779e02
B += 2.33469617e02 * np.sqrt(params["symbolrate"])
B -= 3.31365158e-01 * (params["txpower"]) ** 2
B += 1.32784945e-01 * np.sqrt(params["symbolrate"]) * (params["txpower"]) ** 2
C = 3.65513500e02
C += 8.01016526e04 * 1 / (params["symbolrate"])
D = -7.06364515e-03
D += 8.00029860e03 * 1 / (params["symbolrate"])
x = params["txbytes"]
# in pJ
de_dx = A * D + B * C * 1 / x + B * D * (np.log(x) + 1)
# in µJ
de_dx = 1.13307135e-02
de_dx += 6.29080184e02 * 1 / (params["symbolrate"])
de_dx += 1.31996202e-05 * (params["txpower"]) ** 2
de_dx += 1.25676966e-01 * 1 / (params["symbolrate"]) * (params["txpower"]) ** 2
# de_dx = (B * 1/x) * (C + D * x) + (A + B * np.log(x)) * D
return de_dx * 1e-6
class CC1200rx:
"""CC1200 RX energy based on aemr measurements."""
name = "CC1200rx"
parameters = {
"symbolrate": [6, 12, 25, 50, 100, 200, 250], # ksps
"txbytes": [],
"txpower": [10, 20, 30, 40, 47], # dBm = f(txpower)
}
default_params = {"symbolrate": 100, "txpower": 47}
@staticmethod
def get_energy(params):
# TODO
return params["txbytes"] * CC1200rx.get_energy_per_byte(params)
@staticmethod
def get_energy_per_byte(params):
# RX : 0 + regression_arg(0) + regression_arg(1) * np.log(parameter(symbolrate) + 1)
# [84414.91636169 205.63323036]
de_dx = (
(84414.91636169 + 205.63323036 * np.log(params["symbolrate"] + 1))
* 8000
/ params["symbolrate"]
)
return de_dx * 1e-12
class NRF24L01rx:
"""NRF24L01+ RX energy based on aemr measurements (using variable packet size)"""
name = "NRF24L01"
parameters = {
"datarate": [250, 1000, 2000], # kbps
"txbytes": [],
"txpower": [-18, -12, -6, 0], # dBm
"voltage": [1.9, 3.6],
}
default_params = {"datarate": 1000, "txpower": -6, "voltage": 3}
@staticmethod
def get_energy_per_byte(params):
# RX : 0 + regression_arg(0) + regression_arg(1) * np.sqrt(parameter(datarate))
# [48530.73235537 117.25274402]
de_dx = (
(48530.73235537 + 117.25274402 * np.sqrt(params["datarate"]))
* 8000
/ params["datarate"]
)
return de_dx * 1e-12
# PYTHONPATH=lib bin/analyze-archive.py --show-model=all --show-quality=table ../data/*_RF24_no_retries.tar
class NRF24L01tx:
"""NRF24L01+ TX(*) energy based on aemr measurements (32B fixed packet size, (*)ack-await, no retries)."""
name = "NRF24L01"
parameters = {
"datarate": [250, 1000, 2000], # kbps
"txbytes": [],
"txpower": [-18, -12, -6, 0], # dBm
"voltage": [1.9, 3.6],
}
default_params = {"datarate": 1000, "txpower": -6, "voltage": 3}
# AEMR:
# TX power / energy:
# TX : 0 + regression_arg(0) + regression_arg(1) * 1/(parameter(datarate)) + regression_arg(2) * (19.47+parameter(txpower))**2 + regression_arg(3) * 1/(parameter(datarate)) * (19.47+parameter(txpower))**2
# [6.30323056e+03 2.59889924e+06 7.82186268e+00 8.69746093e+03]
# TX : 0 + regression_arg(0) + regression_arg(1) * 1/(parameter(datarate)) + regression_arg(2) * (19.47+parameter(txpower))**2 + regression_arg(3) * 1/(parameter(datarate)) * (19.47+parameter(txpower))**2
# [7.67932887e+00 1.02969455e+04 4.55116475e-03 2.99786534e+01]
# epilogue : timeout : 0 + regression_arg(0) + regression_arg(1) * 1/(parameter(datarate))
# [ 1624.06589147 332251.93798766]
@staticmethod
def get_energy(params):
if type(params) != dict:
return NRF24L01tx.get_energy(_param_list_to_dict(NRF24L01tx, params))
# TX-Leistung, gefitted von AEMR
# Messdaten erhoben bei 3.6V
power = 6.30323056e03
power += 2.59889924e06 * 1 / params["datarate"]
power += 7.82186268e00 * (19.47 + params["txpower"]) ** 2
power += (
8.69746093e03 * 1 / params["datarate"] * (19.47 + params["txpower"]) ** 2
)
# TX-Dauer, gefitted von AEMR
duration = 1624.06589147
duration += 332251.93798766 * 1 / params["datarate"]
# TX-Energie, gefitted von AEMR
# Achtung: Energy ist in µJ, nicht (wie in AEMR-Transitionsmodellen üblich) in pJ
# Messdaten erhoben bei 3.6V
energy = 7.67932887e00
energy += 1.02969455e04 * 1 / params["datarate"]
energy += 4.55116475e-03 * (19.47 + params["txpower"]) ** 2
energy += (
2.99786534e01 * 1 / params["datarate"] * (19.47 + params["txpower"]) ** 2
)
energy = power * 1e-6 * duration * 1e-6 * np.ceil(params["txbytes"] / 32)
return energy
@staticmethod
def get_energy_per_byte(params):
if type(params) != dict:
return NRF24L01tx.get_energy_per_byte(
_param_list_to_dict(NRF24L01tx, params)
)
# in µJ
de_dx = 0
class NRF24L01dtx:
"""nRF24L01+ TX energy based on datasheet values (probably unerestimated)"""
name = "NRF24L01"
parameters = {
"datarate": [250, 1000, 2000], # kbps
"txbytes": [],
"txpower": [-18, -12, -6, 0], # dBm
"voltage": [1.9, 3.6],
}
default_params = {"datarate": 1000, "txpower": -6, "voltage": 3}
# 130 us RX settling: 8.9 mE
# 130 us TX settling: 8 mA
@staticmethod
def get_energy(params):
if type(params) != dict:
return NRF24L01dtx.get_energy(_param_list_to_dict(NRF24L01dtx, params))
header_bytes = 7
# TX settling: 130 us @ 8 mA
energy = 8e-3 * params["voltage"] * 130e-6
if params["txpower"] == -18:
current = 7e-3
elif params["txpower"] == -12:
current = 7.5e-3
elif params["txpower"] == -6:
current = 9e-3
elif params["txpower"] == 0:
current = 11.3e-3
energy += (
current
* params["voltage"]
* ((header_bytes + params["txbytes"]) * 8 / (params["datarate"] * 1e3))
)
return energy
class ESP8266dtx:
"""esp8266 TX energy based on (hardly documented) datasheet values"""
name = "esp8266"
parameters = {
"voltage": [2.5, 3.0, 3.3, 3.6],
"txbytes": [],
"bitrate": [65e6],
"tx_current": [120e-3],
}
default_params = {"voltage": 3, "bitrate": 65e6, "tx_current": 120e-3}
@staticmethod
def get_energy(params):
# TODO
return 0
@staticmethod
def get_energy_per_byte(params):
if type(params) != dict:
return ESP8266dtx.get_energy_per_byte(
_param_list_to_dict(ESP8266dtx, params)
)
# TX in 802.11n MCS7 -> 64QAM, 65/72.2 Mbit/s @ 20MHz channel, 135/150 Mbit/s @ 40MHz
# -> Value for 65 Mbit/s @ 20MHz channel
return params["tx_current"] * params["voltage"] / params["bitrate"]
class ESP8266drx:
"""esp8266 RX energy based on (hardly documented) datasheet values"""
name = "esp8266"
parameters = {
"voltage": [2.5, 3.0, 3.3, 3.6],
"txbytes": [],
"bitrate": [65e6],
"rx_current": [56e-3],
}
default_params = {"voltage": 3, "bitrate": 65e6, "rx_current": 56e-3}
@staticmethod
def get_energy(params):
# TODO
return 0
@staticmethod
def get_energy_per_byte(params):
if type(params) != dict:
return ESP8266drx.get_energy_per_byte(
_param_list_to_dict(ESP8266drx, params)
)
# TX in 802.11n MCS7 -> 64QAM, 65/72.2 Mbit/s @ 20MHz channel, 135/150 Mbit/s @ 40MHz
# -> Value for 65 Mbit/s @ 20MHz channel
return params["rx_current"] * params["voltage"] / params["bitrate"]