def dln_spislave_set_mode(self, mode): """ Set the SPI mode of the SPI Slave :param mode: possible values are Mode 0 => DLN_SPI_SLAVE_CPOL_0 | DLN_SPI_SLAVE_CPHA_0 Mode 1 => DLN_SPI_SLAVE_CPOL_0 | DLN_SPI_SLAVE_CPHA_1 Mode 2 => DLN_SPI_SLAVE_CPOL_1 | DLN_SPI_SLAVE_CPHA_0 Mode 3 => DLN_SPI_SLAVE_CPOL_1 | DLN_SPI_SLAVE_CPHA_1 :return: """ cpol = 0 cpha = 0 if mode == 1: cpol = 0 cpha = 1 if mode == 2: cpol = 1 cpha = 0 if mode == 3: cpol = 1 cpha = 1 self._import_module_in_wrapper(DLN_MODULE_SPI_SLAVE) enable = self._dlnSpiSlave.dln_spislave_is_enabled(self.__handle, 0) if DLN_SUCCEEDED(enable[0]) and enable[1] == 1: self._dlnSpiSlave.dln_spislave_disable(self.__handle, 0, 0) if DLN_SUCCEEDED(self._dlnSpiSlave.dln_spislave_set_cpol(self.__handle, 0, cpol)) and DLN_SUCCEEDED( self._dlnSpiSlave.dln_spislave_set_cpha(self.__handle, 0, cpha)): res = DLN_RES_SUCCESS else: res = DLN_RES_FAIL if DLN_SUCCEEDED(enable[0]) and enable[1] == 1: enable = self._dlnSpiSlave.dln_spislave_enable(self.__handle, 0) return DLN_SUCCEEDED(enable[0]) and DLN_SUCCEEDED(res)
def enable_spislave(self): """ Enable the SPI Slave :return: True if success, else False """ self._import_module_in_wrapper(DLN_MODULE_SPI_SLAVE) enable = self._dlnSpiSlave.dln_spislave_is_enabled(self.__handle, 0) if DLN_SUCCEEDED(enable[0]) and enable[1] == 0: enable = self._dlnSpiSlave.dln_spislave_enable(self.__handle, 0) return DLN_SUCCEEDED(enable[0])
def dln_spislave_get_supported_framesizes(self): self._import_module_in_wrapper(DLN_MODULE_SPI_SLAVE) enable = self._dlnSpiSlave.dln_spislave_is_enabled(self.__handle, 0) if DLN_SUCCEEDED(enable[0]) and enable[1] == 1: self._dlnSpiSlave.dln_spislave_disable(self.__handle, 0, 0) res = self._dlnSpiSlave.dln_spislave_get_supported_framesizes(self.__handle, 0) if DLN_SUCCEEDED(enable[0]) and enable[1] == 1: enable = self._dlnSpiSlave.dln_spislave_enable(self.__handle, 0) return DLN_SUCCEEDED(enable[0]) and DLN_SUCCEEDED(res[0]), res[1]
def disable_i2cslave(self): """ Disable the I2C Slave :return: True if success, else False """ self._import_module_in_wrapper(DLN_MODULE_I2C_SLAVE) enable = self._dlnI2cSlave.dln_i2cslave_is_enabled(self.__handle, 0) if DLN_SUCCEEDED(enable[0]) and enable[1] == 1: res = self._dlnI2cSlave.dln_i2cslave_disable(self.__handle, 0, 5) return DLN_SUCCEEDED(res) else: return DLN_SUCCEEDED(enable[0])
def dln_spislave_set_framesize(self, framesize): """ Set the frame size of the SPI slave """ self._import_module_in_wrapper(DLN_MODULE_SPI_SLAVE) enable = self._dlnSpiSlave.dln_spislave_is_enabled(self.__handle, 0) if DLN_SUCCEEDED(enable[0]) and enable[1] == 1: self._dlnSpiSlave.dln_spislave_disable(self.__handle, 0, 0) res = self._dlnSpiSlave.dln_spislave_set_framesize(self.__handle, 0, framesize) if DLN_SUCCEEDED(enable[0]) and enable[1] == 1: enable = self._dlnSpiSlave.dln_spislave_enable(self.__handle, 0) return DLN_SUCCEEDED(enable[0]) and DLN_SUCCEEDED(res)
def set_i2cslave_address(self, address): """ Set the I2C slave address :param address: hexa string containing the address to set :return: True if the command was successfully send else False """ self._import_module_in_wrapper(DLN_MODULE_I2C_SLAVE) enable = self._dlnI2cSlave.dln_i2cslave_is_enabled(self.__handle, 0) if DLN_SUCCEEDED(enable[0]) and enable[1] == 1: self._dlnI2cSlave.dln_i2cslave_disable(self.__handle, 0, 0) res = self._dlnI2cSlave.dln_i2cslave_set_address(self.__handle, 0, 1, int(address, 16)) if DLN_SUCCEEDED(enable[0]) and enable[1] == 1: enable = self._dlnI2cSlave.dln_i2cslave_Enable(self.__handle, 0) return DLN_SUCCEEDED(enable[0]) and DLN_SUCCEEDED(res)
def set_spislave_payload(self, payload): """ Set the payload value of the device witch is read on i2cget :param payload: String containing the hex value to load :return: True if the payload was successfully set else false """ self._import_module_in_wrapper(DLN_MODULE_SPI_SLAVE) enable = self._dlnSpiSlave.dln_spislave_is_enabled(self.__handle, 0) if DLN_SUCCEEDED(enable[0]) and enable[1] == 1: self._dlnSpiSlave.dln_spislave_disable(self.__handle, 0, 0) bin_payload = binascii.unhexlify(payload) res = self._dlnSpiSlave.dln_spislave_load_reply(self.__handle, 0, len(bin_payload), bin_payload) if DLN_SUCCEEDED(enable[0]) and enable[1] == 1: enable = self._dlnSpiSlave.dln_spislave_enable(self.__handle, 0) return DLN_SUCCEEDED(enable[0]) and DLN_SUCCEEDED(res)
def enable_i2cslave_notifications(self): """ Enable the I2C Slave notifications :return: """ if self._dlnI2cSlave is not None: enable = self._dlnI2cSlave.dln_i2cslave_is_enabled(self.__handle, 0) if DLN_SUCCEEDED(enable[0]) and enable[1] == 1: self._dlnI2cSlave.dln_i2cslave_disable(self.__handle, 0, 0) from acs_test_scripts.Equipment.IOAdapters.Diolan.Wrapper.DiolanI2CWrapper import DLN_I2C_SLAVE_EVENT_WRITE res = self._dlnI2cSlave.dln_i2cslave_set_event(self.__handle, 0, 1, DLN_I2C_SLAVE_EVENT_WRITE) if DLN_SUCCEEDED(enable[0]) and enable[1] == 1: enable = self._dlnI2cSlave.dln_i2cslave_Enable(self.__handle, 0) return DLN_SUCCEEDED(enable[0]) and DLN_SUCCEEDED(res) else: return False
def dln_spislave_get_mode(self): """ Set the SPI mode of the SPI Slave :return mode: possible values are Mode 0 => DLN_SPI_SLAVE_CPOL_0 | DLN_SPI_SLAVE_CPHA_0 Mode 1 => DLN_SPI_SLAVE_CPOL_0 | DLN_SPI_SLAVE_CPHA_1 Mode 2 => DLN_SPI_SLAVE_CPOL_1 | DLN_SPI_SLAVE_CPHA_0 Mode 3 => DLN_SPI_SLAVE_CPOL_1 | DLN_SPI_SLAVE_CPHA_1 """ self._import_module_in_wrapper(DLN_MODULE_SPI_SLAVE) enable = self._dlnSpiSlave.dln_spislave_is_enabled(self.__handle, 0) if DLN_SUCCEEDED(enable[0]) and enable[1] == 1: self._dlnSpiSlave.dln_spislave_disable(self.__handle, 0, 0) res = self._dlnSpiSlave.dln_spislave_get_mode(self.__handle, 0) if DLN_SUCCEEDED(enable[0]) and enable[1] == 1: enable = self._dlnSpiSlave.dln_spislave_enable(self.__handle, 0) return DLN_SUCCEEDED(enable[0]) and DLN_SUCCEEDED(res[0]), res[1]
def get_i2cslave_address(self): """ Retreive the I2C address of the module :return: string containing address in hexa """ self._import_module_in_wrapper(DLN_MODULE_I2C_SLAVE) res = self._dlnI2cSlave.dln_i2cslave_get_address(self.__handle, 0, 1) if DLN_SUCCEEDED(res[0]): return res[1]
def get_serial_number(self): """ Return the device serial number :return int: serial number """ self._import_module_in_wrapper(DLN_MODULE_GENERIC) res = self._dlnGen.DlnGetDeviceSn(self.__handle) if DLN_SUCCEEDED(res[0]): self._serial_number = res[1] return self._serial_number
def get_version(self): """ get the versions of the Diolan io adapter Hardware_Type_ID | Hardware_model | Hardware_version | Firmware_version | Server_version | Library_Version :return: dictionary containing versions information """ self._import_module_in_wrapper(DLN_MODULE_GENERIC) res = self._dlnGen.DlnGetVersion(self.__handle) if DLN_SUCCEEDED(res[0]): self._format_version(res[1])
def enable_notification_callback(self): """ Enable the Events from Diolan :return: """ self._import_module_in_wrapper(DLN_MODULE_GENERIC) from acs_test_scripts.Equipment.IOAdapters.Diolan.Wrapper.DiolanGenWrapper import PDLN_CALLBACK, DLN_NOTIFICATION_TYPE_CALLBACK self._dlnCallback = PDLN_CALLBACK(self.py_dlnCallback) res = self._dlnGen.dln_register_notification(HDLN_ALL_DEVICES, notification_type=DLN_NOTIFICATION_TYPE_CALLBACK, notification_callback=self._dlnCallback) self._logger.info("DLN register notification ret = " + str(DLN_SUCCEEDED(res)))
def trt_event_notification(self, header, buffer): """ This function handle the I2C Slave events. We handle only the write event to modify the reply registry. :param header: header structure :param buffer: full buffer structure :return: """ if header.msgId == DLN_MSG_ID_I2C_SLAVE_WRITE_EV: event_struct = DLN_I2C_SLAVE_WRITE_EV.from_buffer_copy(buffer) buf = bytearray(event_struct.buffer) buf = buf[:event_struct.size] write = buf[1:].decode('utf-8') # address_index = struct.unpack_from("B", buf[:1])[0] - 1 if event_struct.size == 1: pass #master want writing at address else: # ajust the payload size if len(write) > len(self.__fullPayload): to_add = len(write) - len(self.__fullPayload) self.__fullPayload += '\x00' * to_add # modify the reply registry for count, byte in enumerate(write): payload = list(self.__fullPayload) payload[count] = byte.decode('utf-8') self.__fullPayload = ''.join(payload) # load the new reply registry enable = self.dln_i2cslave_is_enabled(event_struct.header.handle, 0) if DLN_SUCCEEDED(enable[0]) and enable[1] == 1: self.dln_i2cslave_disable(event_struct.header.handle, 0, 0) self.dln_i2cslave_load_reply(event_struct.header.handle, event_struct.port, len(self.__fullPayload), self.__fullPayload) if DLN_SUCCEEDED(enable[0]) and enable[1] == 1: self.dln_i2cslave_Enable(event_struct.header.handle, 0) else: # unknown event pass
def open_device(self, deviceId): """ Open the Diolan io adapter interface :return: handle to the device """ self._import_module_in_wrapper(DLN_MODULE_GENERIC) if deviceId is not None: res = self._dlnGen.dln_open_device_by_id(deviceId) if DLN_SUCCEEDED(res[0]): self.__handle = res[1] else: TestEquipmentException(TestEquipmentException.INVALID_PARAMETER, "Diolan Connection fail") return self.__handle
def py_dlnCallback(self, handle, context_p): """ Callback for the Diolan Events :param handle: :param context_p: :return: """ res = self.__dln_get_message(HDLN_ALL_DEVICES) if DLN_SUCCEEDED(res[0]): return_buf = res[1] header = DLN_MSG_HEADER.from_buffer_copy(return_buf) # DLN_DEVICE_ADDED_EV event doesn't contain device handle - device is not opened yet. # To show device ID and SN in the events list, we open the device and change the handle # in the DLN_DEVICE_ADDED_EV with the new one. # This way the DLN_DEVICE_ADDED_EV can be processed as any other event. if self._dlnI2cSlave is not None: self._dlnI2cSlave.trt_event_notification(header, return_buf) if self._dlnSpiSlave is not None: self._dlnSpiSlave.trt_event_notification(header, return_buf)