Python get_peripheral_config Examples

Example #1

File: test_manager.py Project: bdubrn14/Personal-Food-Computer-PFC-

os.chdir(ROOT_DIR)

# Import device utilities
from device.utilities import accessors
from device.utilities.communication.i2c.mux_simulator import MuxSimulator
from device.utilities.state.main import State

# Import peripheral manager
from device.peripherals.modules.actuator_pcf8574.manager import ActuatorPCF8574Manager

# Load test config
CONFIG_PATH = (
    ROOT_DIR +
    "/device/peripherals/modules/actuator_pcf8574/tests/config.json")
device_config = json.load(open(CONFIG_PATH))
peripheral_config = accessors.get_peripheral_config(
    device_config["peripherals"], "HeaterPTC300")


def test_init() -> None:
    manager = ActuatorPCF8574Manager(
        name="Test",
        i2c_lock=threading.RLock(),
        state=State(),
        config=peripheral_config,
        simulate=True,
        mux_simulator=MuxSimulator(),
    )


def test_initialize_peripheral() -> None:
    manager = ActuatorPCF8574Manager(

Example #2

from device.utilities.accessors import get_peripheral_config
from device.utilities.modes import Modes

# Import device state
from device.state.main import State

# Import simulators
from device.communication.i2c.mux_simulator import MuxSimulator

# Import peripheral manager
from device.peripherals.modules.atlas_do.manager import AtlasDOManager

# Load test config
path = root_dir + "/device/peripherals/modules/atlas_do/tests/config.json"
device_config = json.load(open(path))
peripheral_config = get_peripheral_config(device_config["peripherals"],
                                          "AtlasDO-Reservoir")


def test_init() -> None:
    manager = AtlasDOManager(
        name="Test",
        i2c_lock=threading.RLock(),
        state=State(),
        config=peripheral_config,
        simulate=True,
        mux_simulator=MuxSimulator(),
    )


# def test_initialize() -> None:
#     manager = AtlasDOManager(

Example #3

    def run(self) -> None:
        """Runs peripheral."""

        # Read in arguments
        self.args = self.parser.parse_args()

        # Initialize logger
        if self.args.log_level:
            logging.basicConfig(level=getattr(logging, self.args.log_level))
        else:
            logging.basicConfig(level=self.default_log_level)

        # Check if using defaults
        if self.args.default:

            # Check if defaults are set
            if self.default_device == None or self.default_name == None:
                print("Defaults are not setup")
                sys.exit(0)

            # Set defaults
            self.args.device = self.default_device
            self.args.name = self.default_name

        # Check if listing devices
        if self.args.devices:
            print("Devices:")
            for device in self.devices:
                print("  " + device)
            sys.exit(0)

        # Check for device config argument
        if self.args.device == None:
            print("Please specify a device configuration or use --default")
            print("Note: you can list available device configs with --devices")
            sys.exit(0)

        # Check for existing device config
        if self.args.device not in self.devices:
            print("Invalid device config name")
            print("Note: you can list devices with --devices)")
            sys.exit(0)

        # Load in device config
        self.device_config = json.load(
            open("data/devices/{}.json".format(self.args.device)))

        # Get available peripheral names
        self.names: List[str] = []
        for peripheral in self.device_config["peripherals"]:
            self.names.append(peripheral["name"])
        self.names.sort()

        # Check if listing peripheral names
        if self.args.names:
            print("Peripheral names:")
            for name in self.names:
                print("  " + name)
            sys.exit(0)

        # Check for peripheral name argument
        if self.args.name == None:
            print("Please specify a peripheral name or use --default")
            print("Note: you can list names with --names")
            sys.exit(0)

        # Check for valid peripheral name
        if self.args.name not in self.names:
            print("Invalid peripheral name")
            print("Note: you can list names with --names)")
            sys.exit(0)

        # Initialize peripheral config
        self.peripheral_config = get_peripheral_config(
            self.device_config["peripherals"], self.args.name)

        # Initialize peripheral setup
        setup_name = self.peripheral_config["parameters"]["setup"]["file_name"]
        self.peripheral_setup = json.load(
            open("device/peripherals/modules/" + setup_name + ".json"))

        # Initialize parameters if exist
        self.parameters = self.peripheral_config.get("parameters", {})

        # Initialize communication if exists
        self.communication = self.parameters.get("communication", {})
        if self.communication == None:
            self.communication = {}

        # Initialize standard i2c config parameters if they exist
        self.bus = self.communication.get("bus", None)
        self.address = self.communication.get("address", None)
        self.mux = self.communication.get("mux", None)
        self.channel = self.communication.get("channel", None)

        # Convert i2c config params from hex to int if they exist
        if self.address != None:
            self.address = int(self.address, 16)
        if self.mux != None:
            self.mux = int(self.mux, 16)

Example #4

sys.path.append(ROOT_DIR)
os.chdir(ROOT_DIR)

# Import device utilities
from device.utilities import accessors
from device.utilities.state.main import State
from device.utilities.communication.i2c.mux_simulator import MuxSimulator

# Import manager elements
from device.peripherals.classes.peripheral import modes
from device.peripherals.modules.atlas_temp.manager import AtlasTempManager
from device.peripherals.modules.atlas_temp import events

# Load test config
CONFIG_PATH = ROOT_DIR + "/device/peripherals/modules/atlas_co2/tests/config.json"
device_config = json.load(open(CONFIG_PATH))
peripheral_config = accessors.get_peripheral_config(
    device_config["peripherals"], "AtlasCo2-Top"
)


def test_init() -> None:
    manager = AtlasCo2Manager(
        name="Test",
        i2c_lock=threading.RLock(),
        state=State(),
        config=peripheral_config,
        simulate=True,
        mux_simulator=MuxSimulator(),
    )

Example #5

File: test_dac5578_manager.py Project: bdubrn14/Personal-Food-Computer-PFC-

os.chdir(ROOT_DIR)

# Import device utilities
from device.utilities import accessors
from device.utilities.communication.i2c.mux_simulator import MuxSimulator
from device.utilities.state.main import State

# Import peripheral manager
from device.peripherals.modules.actuator_dac5578.manager import ActuatorDAC5578Manager

# Load test config
CONFIG_PATH = (
    ROOT_DIR + "/device/peripherals/modules/actuator_dac5578/tests/config.json"
)
device_config = json.load(open(CONFIG_PATH))
peripheral_config = accessors.get_peripheral_config(device_config["peripherals"], "Fan")


def test_init() -> None:
    manager = ActuatorDAC5578Manager(
        name="Test",
        i2c_lock=threading.RLock(),
        state=State(),
        config=peripheral_config,
        simulate=True,
        mux_simulator=MuxSimulator(),
    )


def test_peripheral_initialize() -> None:
    manager = ActuatorDAC5578Manager(

Example #6

sys.path.append(root_dir)
os.chdir(root_dir)

# Import device utilities
from device.utilities.accessors import get_peripheral_config

# Import mux simulator
from device.utilities.communication.i2c.mux_simulator import MuxSimulator

# Import peripheral driver
from device.peripherals.modules.led_dac5578.driver import LEDDAC5578Driver

# Load test config and setup
base_path = root_dir + "/device/peripherals/modules/led_dac5578/tests/"
device_config = json.load(open(base_path + "config.json"))
peripheral_config = get_peripheral_config(device_config["peripherals"],
                                          "LEDPanel-1")
panel_configs = peripheral_config["parameters"]["communication"]["panels"]
peripheral_setup = json.load(open(base_path + "setup.json"))
panel_properties = peripheral_setup["properties"]


def test_init() -> None:
    driver = LEDDAC5578Driver(
        name="Test",
        panel_configs=panel_configs,
        panel_properties=panel_properties,
        i2c_lock=threading.RLock(),
        simulate=True,
        mux_simulator=MuxSimulator(),
    )

Example #7

from device.utilities.modes import Modes

# Import device state
from device.state.main import State

# Import simulators
from device.communication.i2c.mux_simulator import MuxSimulator
from device.peripherals.modules.t6713.simulator import T6713Simulator

# Import peripheral manager
from device.peripherals.modules.t6713.manager import T6713Manager

# Load test config
path = root_dir + "/device/peripherals/modules/t6713/tests/config.json"
device_config = json.load(open(path))
peripheral_config = get_peripheral_config(device_config["peripherals"], "T6713-Top")


def test_init() -> None:
    manager = T6713Manager(
        name="Test",
        i2c_lock=threading.RLock(),
        state=State(),
        config=peripheral_config,
        simulate=True,
        mux_simulator=MuxSimulator(),
    )


def test_initialize() -> None:
    manager = T6713Manager(

Example #8

File: test_manager.py Project: bdubrn14/Personal-Food-Computer-PFC-

os.chdir(ROOT_DIR)

# Import device utilities
from device.utilities import accessors
from device.utilities.state.main import State
from device.utilities.communication.i2c.mux_simulator import MuxSimulator

# Import manager elements
from device.peripherals.classes.peripheral import modes
from device.peripherals.modules.atlas_ph.manager import AtlasPHManager
from device.peripherals.modules.atlas_ph import events

# Load test config
CONFIG_PATH = ROOT_DIR + "/device/peripherals/modules/atlas_ph/tests/config.json"
device_config = json.load(open(CONFIG_PATH))
peripheral_config = accessors.get_peripheral_config(
    device_config["peripherals"], "AtlasPH-Reservoir")


def test_init() -> None:
    manager = AtlasPHManager(
        name="Test",
        i2c_lock=threading.RLock(),
        state=State(),
        config=peripheral_config,
        simulate=True,
        mux_simulator=MuxSimulator(),
    )


def test_initialize_peripheral() -> None:
    manager = AtlasPHManager(

Example #9

File: test_manager.py Project: bdubrn14/Personal-Food-Computer-PFC-

sys.path.append(root_dir)
os.chdir(root_dir)

# Import device utilities
from device.utilities.logger import Logger
from device.utilities.accessors import get_peripheral_config
from device.utilities.state.main import State

# Import manager elements
from device.peripherals.classes.peripheral.manager import PeripheralManager
from device.peripherals.classes.peripheral import modes, events

# Load test config
path = root_dir + "/device/peripherals/classes/peripheral/tests/config.json"
device_config = json.load(open(path))
peripheral_config = get_peripheral_config(device_config["peripherals"], "Camera-Top")


def test_init() -> None:
    manager = PeripheralManager(
        name="Test",
        state=State(),
        config=peripheral_config,
        i2c_lock=threading.RLock(),
        simulate=True,
    )


def test_run_init_mode() -> None:
    manager = PeripheralManager(
        name="Test",

Example #10

File: test_manager.py Project: rezarajan/tgcpifiles

ROOT_DIR = os.environ["PROJECT_ROOT"]
sys.path.append(ROOT_DIR)
os.chdir(ROOT_DIR)

# Import device utilities
from device.utilities import accessors
from device.utilities.communication.i2c.mux_simulator import MuxSimulator
from device.utilities.state.main import State

# Import peripheral manager
from device.peripherals.modules.led_spacemod.manager import LEDSpacemodManager

# Load test config and setup
CONFIG_PATH = "device/peripherals/modules/led_dac5578/tests/config.json"
device_config = json.load(open(CONFIG_PATH))
peripheral_config = accessors.get_peripheral_config(
    device_config["peripherals"], "LEDPanel-1")


def test_init() -> None:
    manager = LEDSpacemodManager(
        name="Test",
        i2c_lock=threading.RLock(),
        state=State(),
        config=peripheral_config,
        simulate=True,
        mux_simulator=MuxSimulator(),
    )


def test_initialize_peripheral() -> None:
    manager = LEDSpacemodManager(

Example #11

ROOT_DIR = os.environ["OPENAG_BRAIN_ROOT"]
sys.path.append(ROOT_DIR)
os.chdir(ROOT_DIR)

# Import device utilities
from device.utilities import accessors
from device.utilities.communication.i2c.mux_simulator import MuxSimulator
from device.utilities.state.main import State

# Import peripheral manager
from device.peripherals.modules.sht25.manager import SHT25Manager

# Load test config
CONFIG_PATH = ROOT_DIR + "/device/peripherals/modules/sht25/tests/config.json"
device_config = json.load(open(CONFIG_PATH))
peripheral_config = accessors.get_peripheral_config(
    device_config["peripherals"], "SHT25-Top")


def test_init() -> None:
    manager = SHT25Manager(
        name="Test",
        i2c_lock=threading.RLock(),
        state=State(),
        config=peripheral_config,
        simulate=True,
        mux_simulator=MuxSimulator(),
    )


def test_initialize_peripheral() -> None:
    manager = SHT25Manager(

Example #12

ROOT_DIR = os.environ["OPENAG_BRAIN_ROOT"]
sys.path.append(ROOT_DIR)
os.chdir(ROOT_DIR)

# Import device utilities
from device.utilities.accessors import get_peripheral_config
from device.utilities.communication.i2c.mux_simulator import MuxSimulator
from device.utilities.state.main import State

# Import peripheral manager
from device.peripherals.modules.ccs811.manager import CCS811Manager

# Load test config
CONFIG_PATH = ROOT_DIR + "/device/peripherals/modules/ccs811/tests/config.json"
device_config = json.load(open(CONFIG_PATH))
peripheral_config = get_peripheral_config(device_config["peripherals"],
                                          "CCS811-Top")


def test_init() -> None:
    manager = CCS811Manager(
        name="Test",
        i2c_lock=threading.RLock(),
        state=State(),
        config=peripheral_config,
        simulate=True,
        mux_simulator=MuxSimulator(),
    )


# def test_initialize_peripheral() -> None:
#     manager = CCS811Manager(

Example #13

# Import device utilities
from device.utilities import accessors
from device.utilities.communication.i2c.mux_simulator import MuxSimulator
from device.utilities.state.main import State

# Import peripheral manager
from device.peripherals.modules.actuator_grove_rgb_lcd.manager import (
    ActuatorGroveRGBLCDManager, )

# Load test config
PERIPHERAL_NAME = "LCD"
CONFIG_PATH = (
    ROOT_DIR +
    "/device/peripherals/modules/actuator_grove_rgb_lcd/tests/config.json")
device_config = json.load(open(CONFIG_PATH))
peripheral_config = accessors.get_peripheral_config(
    device_config["peripherals"], PERIPHERAL_NAME)


def test_init() -> None:
    manager = ActuatorGroveRGBLCDManager(
        name="Test",
        i2c_lock=threading.RLock(),
        state=State(),
        config=peripheral_config,
        simulate=True,
        mux_simulator=MuxSimulator(),
    )


def test_peripheral_initialize() -> None:
    manager = ActuatorGroveRGBLCDManager(

Example #14

File: test_manager.py Project: alexking/openag-device-software

from device.utilities.accessors import get_peripheral_config
from device.utilities.modes import Modes

# Import device state
from device.state.main import State

# Import simulators
from device.communication.i2c.mux_simulator import MuxSimulator

# Import peripheral manager
from device.peripherals.modules.sht25.manager import SHT25Manager

# Load test config
path = root_dir + "/device/peripherals/modules/sht25/tests/config.json"
device_config = json.load(open(path))
peripheral_config = get_peripheral_config(device_config["peripherals"],
                                          "SHT25-Top")


def test_init() -> None:
    manager = SHT25Manager(
        name="Test",
        i2c_lock=threading.RLock(),
        state=State(),
        config=peripheral_config,
        simulate=True,
        mux_simulator=MuxSimulator(),
    )


def test_initialize() -> None:
    manager = SHT25Manager(

Example #15

sys.path.append(ROOT_DIR)
os.chdir(ROOT_DIR)

# Import device utilities
from device.utilities import accessors
from device.utilities.state.main import State
from device.utilities.communication.i2c.mux_simulator import MuxSimulator

# Import peripheral manager
from device.peripherals.modules.usb_camera.manager import USBCameraManager

# Load test config
CONFIG_PATH = ROOT_DIR + "/device/peripherals/modules/usb_camera/tests/config.json"
device_config = json.load(open(CONFIG_PATH))
peripheral_config = accessors.get_peripheral_config(
    device_config["peripherals"], "Camera-Top"
)


def test_init() -> None:
    manager = USBCameraManager(
        name="Test",
        i2c_lock=threading.RLock(),
        state=State(),
        config=peripheral_config,
        simulate=True,
        mux_simulator=MuxSimulator(),
    )


def test_initialize_peripheral() -> None:

Example #16

ROOT_DIR = os.environ["PROJECT_ROOT"]
sys.path.append(ROOT_DIR)
os.chdir(ROOT_DIR)

# Import device utilities
from device.utilities import accessors
from device.utilities.communication.i2c.mux_simulator import MuxSimulator
from device.utilities.state.main import State

# Import peripheral manager
from device.peripherals.modules.adafruit_soil.manager import AdafruitSoilManager

# Load test config
CONFIG_PATH = ROOT_DIR + "/device/peripherals/modules/adafruit_soil/tests/config.json"
device_config = json.load(open(CONFIG_PATH))
peripheral_config = accessors.get_peripheral_config(
    device_config["peripherals"], "AdafruitSoil")


def test_init() -> None:
    manager = AdafruitSoilManager(
        name="Test",
        i2c_lock=threading.RLock(),
        state=State(),
        config=peripheral_config,
        simulate=True,
        mux_simulator=MuxSimulator(),
    )


def test_initialize_peripheral() -> None:
    manager = AdafruitSoilManager(