4d207895b4
Fix pylint warnings like these:
Comparison to True should be just 'expr' (singleton-comparison)
Comparison to False should be 'not expr' (singleton-comparison)
I checked that GPIO.read() only returns True/False in the
python-periphery docs.
Getting rid of pylint warnings for a CI check.
Signed-off-by: Ulf Magnusson <Ulf.Magnusson@nordicsemi.no>
125 lines
4.1 KiB
Python
125 lines
4.1 KiB
Python
#!/usr/bin/env python3
|
|
#
|
|
# Copyright (c) 2019 Intel Corporation
|
|
#
|
|
# SPDX-License-Identifier: Apache-2.0
|
|
#
|
|
# Author: Sathish Kuttan <sathish.k.kuttan@intel.com>
|
|
|
|
# This file defines device class that contains functions to
|
|
# setup/cconfigure SPI master device and GPIO pins required
|
|
# to communicate with the target.
|
|
# Member functions are provided to send and receive messages
|
|
# over the SPI bus
|
|
|
|
import yaml
|
|
import time
|
|
import periphery
|
|
import sys
|
|
import os
|
|
|
|
class Device:
|
|
"""
|
|
Device class containing the interface methods for communicating
|
|
with the target using SPI bus and GPIOs
|
|
"""
|
|
def __init__(self):
|
|
"""
|
|
Read config file and determine the SPI device, speed, mode
|
|
GPIO pin assignments, etc.
|
|
Initialize data structures accordingly.
|
|
"""
|
|
config_file = os.path.dirname(__file__)
|
|
config_file += '/config.yml'
|
|
with open(config_file, 'r') as ymlfile:
|
|
config = yaml.safe_load(ymlfile)
|
|
self.name = config['general']['name']
|
|
self.spi_device = config['spi']['device']
|
|
self.spi_speed = config['spi']['max_speed']
|
|
self.spi_mode = None
|
|
self.gpio_reset = config['gpio']['reset']
|
|
self.gpio_wake = config['gpio']['wake']
|
|
self.gpio_irq = config['gpio']['irq']
|
|
self.spi = None
|
|
self.reset_pin = None
|
|
self.wake_pin = None
|
|
self.irq_pin = None
|
|
|
|
def print_config(self):
|
|
"""
|
|
Print configuration information that was read from config file
|
|
"""
|
|
print('%s Device on %s' %(self.name, self.spi_device))
|
|
print('Max SPI Frequency: %2.1f MHz' % self.spi_speed)
|
|
print('Reset GPIO: %d' % self.gpio_reset)
|
|
print('Wake GPIO : %d' % self.gpio_wake)
|
|
print('IRQ GPIO : %d' % self.gpio_irq)
|
|
|
|
def configure_device(self, spi_mode, order, bits):
|
|
"""
|
|
Configure the SPI device and GPIOs for communication with target
|
|
"""
|
|
self.reset_pin = periphery.GPIO(self.gpio_reset, 'out')
|
|
self.wake_pin = periphery.GPIO(self.gpio_wake, 'out')
|
|
self.irq_pin = periphery.GPIO(self.gpio_irq, 'in')
|
|
self.spi = periphery.SPI(self.spi_device, spi_mode,
|
|
self.spi_speed * 1e6)
|
|
self.spi.bit_order = order
|
|
self.spi.bits_per_word = bits
|
|
print('Configured SPI %s for %s.' % (self.spi_device, self.name))
|
|
print('Configured GPIO %d for %s Reset.' % (self.gpio_reset, self.name))
|
|
print('Configured GPIO %d for %s Wake.' % (self.gpio_wake, self.name))
|
|
print('Configured GPIO %d for %s IRQ.' % (self.gpio_irq, self.name))
|
|
|
|
def check_device_ready(self):
|
|
"""
|
|
Check whether the target is ready to accept a command as follows:
|
|
Wait a minimum time and check whether IRQ is asserted by the target
|
|
If IRQ is not asserted, wait maximum time and check again.
|
|
Device is ready if IRQ is asserted
|
|
"""
|
|
min_wait = 0.001 # 1 ms
|
|
max_wait = 0.1 # 100 ms
|
|
time.sleep(min_wait)
|
|
ready = self.irq_pin.read()
|
|
if not ready:
|
|
time.sleep(max_wait)
|
|
ready = self.irq_pin.read()
|
|
if not ready:
|
|
print('Error: Device not ready', file=sys.stderr)
|
|
return ready
|
|
|
|
def reset_device(self):
|
|
"""
|
|
Assert the GPIO and deassert after a short duration to reset
|
|
the target.
|
|
"""
|
|
print('Resetting %s ...' % self.name)
|
|
self.reset_pin.write(False)
|
|
time.sleep(0.1)
|
|
self.reset_pin.write(True)
|
|
self.check_device_ready()
|
|
|
|
def send_receive(self, data, wait=True):
|
|
"""
|
|
Transmit and receive full duplex data over SPI
|
|
If requested to wait, wait for device to become ready
|
|
before return.
|
|
"""
|
|
rx_data = self.spi.transfer(data)
|
|
if wait:
|
|
self.check_device_ready()
|
|
return rx_data
|
|
|
|
def send_bulk(self, data):
|
|
"""
|
|
Send a byte stream of data without checking for device readiness.
|
|
"""
|
|
self.spi.transfer(data)
|
|
|
|
def close(self):
|
|
"""
|
|
Close the device handle
|
|
"""
|
|
self.spi.close()
|