test.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "import hid\n",
    "import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "class FT260HidDriver():\n",
    "\n",
    "    \"\"\"\n",
    "    Key to symbols\n",
    "    ==============\n",
    "\n",
    "    S     (1 bit) : Start bit\n",
    "    P     (1 bit) : Stop bit\n",
    "    Rd/Wr (1 bit) : Read/Write bit. Rd equals 1, Wr equals 0.\n",
    "    A, NA (1 bit) : Accept and reverse accept bit.\n",
    "    Addr  (7 bits): I2C 7 bit address. Note that this can be expanded as usual to\n",
    "                    get a 10 bit I2C address.\n",
    "    Comm  (8 bits): Command byte, a data byte which often selects a register on\n",
    "                    the device.\n",
    "    Data  (8 bits): A plain data byte. Sometimes, I write DataLow, DataHigh\n",
    "                    for 16 bit data.\n",
    "    Count (8 bits): A data byte containing the length of a block operation.\n",
    "\n",
    "    [..]: Data sent by I2C device, as opposed to data sent by the host adapter.\n",
    "\n",
    "    More detail documentation is at https://www.kernel.org/doc/Documentation/i2c/smbus-protocol\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, port, device):\n",
    "        self.port = port\n",
    "        #self.smbus = smbus\n",
    "        self.driver_type = 'ft260_hid'\n",
    "        dev = device\n",
    "        self.initialize_ftdi()\n",
    "    \n",
    "\n",
    "\n",
    "    def initialize_ftdi(self):\n",
    "        # TODO pripojeni k HID, nyni to mam jako dev\n",
    "        \n",
    "        print(f'Device manufacturer: {dev.get_manufacturer_string()}')\n",
    "        print(f'Product: {dev.get_product_string()}')\n",
    "        print(f'Serial Number: {dev.get_serial_number_string()}')\n",
    "\n",
    "        dev.set_nonblocking(0)\n",
    "\n",
    "        self.reset_i2c()\n",
    "        #self.set_i2c_speed(100000) # 100 Khz\n",
    "        self.get_i2c_status()\n",
    "\n",
    "\n",
    "    def get_i2c_status(self):\n",
    "        d = dev.get_feature_report(0xC0, 100)\n",
    "\n",
    "        status = ['busy_chip', 'error', 'no_ack', 'arbitration_lost', 'idle', 'busy_bus']\n",
    "        bits = [(d[1] & (1 << i)) >> i for i in range(8)]\n",
    "        status = dict(zip(status, bits))\n",
    "\n",
    "        baudrate = (d[2] | d[3]<<8)*1000\n",
    "        status['baudrate'] = baudrate\n",
    "\n",
    "        return status\n",
    "        \n",
    "    \n",
    "    def reset_i2c(self):\n",
    "        dev.send_feature_report([0xA1, 0x20])\n",
    "        \n",
    "    def set_i2c_speed(self, speed = 100000):\n",
    "        speed = int(speed/1000)\n",
    "        LSB = (speed & 0xff)\n",
    "        MSB = (speed>>8 & 0xff)\n",
    "        print(f\"Nastavit speed na {speed} Hz: \", hex(LSB), hex(MSB))\n",
    "        dev.send_feature_report([0xA1, 0x22, LSB, MSB])\n",
    "\n",
    "\n",
    "    def write_byte(self, address, value):\n",
    "        \"\"\"\n",
    "        SMBus Send Byte:  i2c_smbus_write_byte()\n",
    "        ========================================\n",
    "\n",
    "        This operation is the reverse of Receive Byte: it sends a single byte\n",
    "        to a device.  See Receive Byte for more information.\n",
    "\n",
    "        S Addr Wr [A] Data [A] P\n",
    "\n",
    "        Functionality flag: I2C_FUNC_SMBUS_WRITE_BYTE\n",
    "        \"\"\"\n",
    "\n",
    "        return None\n",
    "\n",
    "    def read_byte(self, address):\n",
    "        \"\"\"\n",
    "        SMBus Send Byte:  i2c_smbus_write_byte()\n",
    "        ========================================\n",
    "\n",
    "        This operation is the reverse of Receive Byte: it sends a single byte\n",
    "        to a device.  See Receive Byte for more information.\n",
    "\n",
    "        S Addr Wr [A] Data [A] P\n",
    "\n",
    "        Functionality flag: I2C_FUNC_SMBUS_WRITE_BYTE\n",
    "        \"\"\"\n",
    "        return None\n",
    "\n",
    "    def write_byte_data(self, address, register, value):\n",
    "        \"\"\"\n",
    "        SMBus Read Byte:  i2c_smbus_read_byte_data()\n",
    "        ============================================\n",
    "\n",
    "        This reads a single byte from a device, from a designated register.\n",
    "        The register is specified through the Comm byte.\n",
    "\n",
    "        S Addr Wr [A] Comm [A] S Addr Rd [A] [Data] NA P\n",
    "\n",
    "        Functionality flag: I2C_FUNC_SMBUS_READ_BYTE_DATA\n",
    "        \"\"\"\n",
    "\n",
    "        return dev.write([0xD0, address, 0x06, 2, register, value])\n",
    "\n",
    "\n",
    "    def read_byte_data(self, address, register):\n",
    "        \"\"\"\n",
    "        SMBus Read Byte:  i2c_smbus_read_byte_data()\n",
    "        ============================================\n",
    "\n",
    "        This reads a single byte from a device, from a designated register.\n",
    "        The register is specified through the Comm byte.\n",
    "\n",
    "        S Addr Wr [A] Comm [A] S Addr Rd [A] [Data] NA P\n",
    "\n",
    "        Functionality flag: I2C_FUNC_SMBUS_READ_BYTE_DATA\n",
    "        \"\"\"\n",
    "\n",
    "\n",
    "        payload = [0xD0, address, 0x06, 0b01, register]\n",
    "        dev.write(payload)\n",
    "        length = (1).to_bytes(2, byteorder='little')\n",
    "        dev.write([0xC2, address, 0x06, length[0], length[1]])\n",
    "        d = dev.read(0xde)\n",
    "\n",
    "        # TODO: Osetrit chyby v chybnem vycteni registru\n",
    "        return d[2]\n",
    "\n",
    "\n",
    "    def write_word_data(self, address, register, value):\n",
    "        \"\"\"\n",
    "        SMBus Write Word:  i2c_smbus_write_word_data()\n",
    "        ==============================================\n",
    "\n",
    "        This is the opposite of the Read Word operation. 16 bits\n",
    "        of data is written to a device, to the designated register that is\n",
    "        specified through the Comm byte.\n",
    "\n",
    "        S Addr Wr [A] Comm [A] DataLow [A] DataHigh [A] P\n",
    "\n",
    "        Functionality flag: I2C_FUNC_SMBUS_WRITE_WORD_DATA\n",
    "\n",
    "        Note the convenience function i2c_smbus_write_word_swapped is\n",
    "        available for writes where the two data bytes are the other way\n",
    "        around (not SMBus compliant, but very popular.)\n",
    "        \"\"\"\n",
    "        return dev.write([0xD0, address, 0x06, 3, register, (value)&0xff, (value>>8)&0xff ])\n",
    "\n",
    "    def read_word_data(self, address, register):\n",
    "        \"\"\"\n",
    "        SMBus Read Word:  i2c_smbus_read_word_data()\n",
    "        ============================================\n",
    "\n",
    "        This operation is very like Read Byte; again, data is read from a\n",
    "        device, from a designated register that is specified through the Comm\n",
    "        byte. But this time, the data is a complete word (16 bits).\n",
    "\n",
    "        S Addr Wr [A] Comm [A] S Addr Rd [A] [DataLow] A [DataHigh] NA P\n",
    "\n",
    "        Functionality flag: I2C_FUNC_SMBUS_READ_WORD_DATA\n",
    "\n",
    "        Note the convenience function i2c_smbus_read_word_swapped is\n",
    "        available for reads where the two data bytes are the other way\n",
    "        around (not SMBus compliant, but very popular.)\n",
    "        \"\"\"\n",
    "\n",
    "        payload = [0xD0, address, 0x06, 0b01, register]\n",
    "        dev.write(payload)\n",
    "        length = (2).to_bytes(2, byteorder='little')\n",
    "        dev.write([0xC2, address, 0x06, length[0], length[1]])\n",
    "        d = dev.read(0xde)\n",
    "\n",
    "        # TODO: Osetrit chyby v chybnem vycteni registru\n",
    "        return d[2]<<8 | d[3]\n",
    "\n",
    "    def write_block_data(self, address, register, value):\n",
    "        \"\"\"\n",
    "        SMBus Block Write:  i2c_smbus_write_block_data()\n",
    "        ================================================\n",
    "\n",
    "        The opposite of the Block Read command, this writes up to 32 bytes to\n",
    "        a device, to a designated register that is specified through the\n",
    "        Comm byte. The amount of data is specified in the Count byte.\n",
    "\n",
    "        S Addr Wr [A] Comm [A] Count [A] Data [A] Data [A] ... [A] Data [A] P\n",
    "\n",
    "        Functionality flag: I2C_FUNC_SMBUS_WRITE_BLOCK_DATA\n",
    "        \"\"\"\n",
    "        raise NotImplementedError\n",
    "\n",
    "    def read_block_data(self, address, register):\n",
    "        \"\"\"\n",
    "        SMBus Block Read:  i2c_smbus_read_block_data()\n",
    "        ==============================================\n",
    "\n",
    "        This command reads a block of up to 32 bytes from a device, from a\n",
    "        designated register that is specified through the Comm byte. The amount\n",
    "        of data is specified by the device in the Count byte.\n",
    "\n",
    "        S Addr Wr [A] Comm [A]\n",
    "                   S Addr Rd [A] [Count] A [Data] A [Data] A ... A [Data] NA P\n",
    "\n",
    "        Functionality flag: I2C_FUNC_SMBUS_READ_BLOCK_DATA\n",
    "        \"\"\"\n",
    "        raise NotImplementedError\n",
    "\n",
    "    def block_process_call(self, address, register, value):\n",
    "        \"\"\"\n",
    "        SMBus Block Write - Block Read Process Call\n",
    "        ===========================================\n",
    "\n",
    "        SMBus Block Write - Block Read Process Call was introduced in\n",
    "        Revision 2.0 of the specification.\n",
    "\n",
    "        This command selects a device register (through the Comm byte), sends\n",
    "        1 to 31 bytes of data to it, and reads 1 to 31 bytes of data in return.\n",
    "\n",
    "        S Addr Wr [A] Comm [A] Count [A] Data [A] ...\n",
    "                                     S Addr Rd [A] [Count] A [Data] ... A P\n",
    "\n",
    "        Functionality flag: I2C_FUNC_SMBUS_BLOCK_PROC_CALL\n",
    "        \"\"\"\n",
    "        raise NotImplementedError\n",
    "\n",
    "    ### I2C transactions not compatible with pure SMBus driver\n",
    "    def write_i2c_block(self, address, value):\n",
    "        \"\"\"\n",
    "        Simple send transaction\n",
    "        ======================\n",
    "\n",
    "        This corresponds to i2c_master_send.\n",
    "\n",
    "          S Addr Wr [A] Data [A] Data [A] ... [A] Data [A] P\n",
    "\n",
    "        More detail documentation is at: https://www.kernel.org/doc/Documentation/i2c/i2c-protocol\n",
    "        \"\"\"\n",
    "        raise NotImplementedError\n",
    "\n",
    "    def read_i2c_block(self, address, length):\n",
    "        \"\"\"\n",
    "        Simple receive transaction\n",
    "        ===========================\n",
    "\n",
    "        This corresponds to i2c_master_recv\n",
    "\n",
    "          S Addr Rd [A] [Data] A [Data] A ... A [Data] NA P\n",
    "\n",
    "        More detail documentation is at: https://www.kernel.org/doc/Documentation/i2c/i2c-protocol\n",
    "        \"\"\"\n",
    "        raise NotImplementedError\n",
    "\n",
    "    # def write_i2c_block_data(self, address, register, value):\n",
    "    #     \"\"\"\n",
    "    #     I2C block transactions do not limit the number of bytes transferred\n",
    "    #     but the SMBus layer places a limit of 32 bytes.\n",
    "\n",
    "    #     I2C Block Write:  i2c_smbus_write_i2c_block_data()\n",
    "    #     ==================================================\n",
    "\n",
    "    #     The opposite of the Block Read command, this writes bytes to\n",
    "    #     a device, to a designated register that is specified through the\n",
    "    #     Comm byte. Note that command lengths of 0, 2, or more bytes are\n",
    "    #     supported as they are indistinguishable from data.\n",
    "\n",
    "    #     S Addr Wr [A] Comm [A] Data [A] Data [A] ... [A] Data [A] P\n",
    "\n",
    "    #     Functionality flag: I2C_FUNC_SMBUS_WRITE_I2C_BLOCK\n",
    "    #     \"\"\"\n",
    "        \n",
    "    #     payload = [0xD0, address, 0x06, len(value) + 1, register] + value\n",
    "    #     dev.write(payload)\n",
    "\n",
    "\n",
    "    # def read_i2c_block_data(self, address, register, length):\n",
    "    #     data = []\n",
    "    #     for i in range(length):\n",
    "    #         self.write_byte_data(address, register, i)\n",
    "    #         byte = self.read_byte(address)\n",
    "    #         data.append(byte)\n",
    "    #     return data\n",
    "        \n",
    "    def read_i2c_block_data(self, address, register, length):\n",
    "        \"\"\"\n",
    "        I2C Block Read: i2c_smbus_read_i2c_block_data()\n",
    "        =================================================\n",
    "\n",
    "        Reads a block of bytes from a specific register in a device. It's the direct\n",
    "        opposite of the Block Write command, primarily used for retrieving a series\n",
    "        of bytes from a given register.\n",
    "\n",
    "        S Addr Wr [A] Comm [A] S Addr Rd [A] Data [A] Data [A] ... [A] Data [A] P\n",
    "\n",
    "        The method respects SMBus limitations of 32 bytes for block transactions.\n",
    "        \"\"\"\n",
    "\n",
    "        print(\" .. \")\n",
    "        print(\"READ BLOCK DATA\", address, register, length)\n",
    "\n",
    "        if length > 60:\n",
    "            raise ValueError(\"Attempt to read more than 60 bytes exceeds the limit.\")\n",
    "\n",
    "        read_cmd = [\n",
    "            0xD0,              # Report ID pro čtení je 0xD0 podle dokumentace\n",
    "            address,           # 7-bitová I2C adresa a R/W bit nastaven na čtení (1)\n",
    "            0x02,\n",
    "            2,  \n",
    "            0, register,          # Registru, ze kterého chceme číst\n",
    "        ]\n",
    "        print(\"SEND WRITE REQ\", [hex(x) for x in read_cmd])\n",
    "        dev.write(read_cmd)\n",
    "\n",
    "\n",
    "        # Příprava I2C čtecího požadavku\n",
    "        length_b = (2).to_bytes(length, byteorder='little')\n",
    "        read_request = [\n",
    "            0xC2, \n",
    "            address,\n",
    "            0x04,\n",
    "            #length_b[0],\n",
    "            #length_b[1],\n",
    "            length, 0\n",
    "            #0xDE,\n",
    "            #register           # Registru, ze kterého chceme číst\n",
    "        ]\n",
    "\n",
    "        print(\"SEND READ REQ\", [hex(x) for x in read_request])\n",
    "\n",
    "        # Odeslání požadavku pro čtení\n",
    "        dev.write(read_request)\n",
    "\n",
    "        # Přijetí dat z I2C zařízení\n",
    "        received_data = dev.read(length)\n",
    "\n",
    "\n",
    "        print(\"RECIEVED\", [hex(x) for x in received_data])\n",
    "        print(\"RECIEVED\", received_data)\n",
    "\n",
    "        return received_data\n",
    "\n",
    "    def write_i2c_block_data(self, address, register, data):\n",
    "        \"\"\"\n",
    "        I2C Block Write: i2c_smbus_write_i2c_block_data()\n",
    "        =================================================\n",
    "\n",
    "        Writes a block of bytes to a specific register in a device. This command\n",
    "        is designed for direct I2C communication, allowing for command lengths of 0,\n",
    "        2, or more bytes, which are indistinguishable from data.\n",
    "\n",
    "        S Addr Wr [A] Comm [A] Data [A] Data [A] ... [A] Data [A] P\n",
    "\n",
    "        Functionality flag: I2C_FUNC_SMBUS_WRITE_I2C_BLOCK\n",
    "        \"\"\"\n",
    "\n",
    "        data_length = len(data)\n",
    "        report_id = 0xD0 + (data_length - 1) // 4\n",
    "\n",
    "        if data_length > 60:\n",
    "            raise ValueError(\"Data block size must not exceed 60 bytes.\")\n",
    "\n",
    "        # Příprava I2C zápisového požadavku\n",
    "        write_request = [\n",
    "            report_id,              # Report ID, který odpovídá velikosti dat\n",
    "            address,           # 7-bitová I2C adresa a W/R bit nastaven na zápis (0)\n",
    "            0x06,                   # Příznak pro START_AND_STOP\n",
    "        ] + [data_length] + data   # Délka dat následována daty\n",
    "\n",
    "        print(\"SEND WRITE REQ\", write_request)\n",
    "        # Odeslání požadavku pro zápis dat do I2C zařízení\n",
    "        dev.write(write_request)\n",
    "\n",
    "        return True\n",
    "    \n",
    "    def block_process_call(self, address, register, value):\n",
    "        if len(value) > 31:\n",
    "            raise ValueError(\"Block process call cannot handle more than 31 bytes\")\n",
    "        count = len(value)\n",
    "        write_payload = [0xD0, address, 0x06, register, count] + value\n",
    "        dev.write(write_payload)\n",
    "\n",
    "        # Read the response block\n",
    "        response_count = dev.read(0xDE, 1)[0]\n",
    "        response_data = dev.read(0xDE, response_count)\n",
    "        return response_data\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0xa0 65535\n",
      "0xa2 47332\n",
      "0xa4 46547\n",
      "0xa6 29640\n",
      "0xa8 26452\n",
      "0xaa 34290\n",
      "0xac 28144\n",
      "PRESSURE\n",
      "8665158\n",
      "PRESSURE\n",
      "8665624\n",
      "PRESSURE\n",
      "8664618\n",
      "PRESSURE\n",
      "8665046\n",
      "PRESSURE\n",
      "8665130\n",
      "PRESSURE\n",
      "8665706\n",
      "PRESSURE\n",
      "8665576\n",
      "PRESSURE\n",
      "8665372\n",
      "PRESSURE\n",
      "8664744\n",
      "PRESSURE\n",
      "8664922\n",
      "PRESSURE\n",
      "8664926\n",
      "PRESSURE\n",
      "8665860\n",
      "PRESSURE\n",
      "8665200\n",
      "PRESSURE\n",
      "8665348\n",
      "PRESSURE\n",
      "8665278\n",
      "PRESSURE\n",
      "8664312\n",
      "PRESSURE\n",
      "8664280\n",
      "PRESSURE\n",
      "8665298\n",
      "PRESSURE\n",
      "8665364\n",
      "PRESSURE\n",
      "8666186\n",
      "PRESSURE\n",
      "8665068\n",
      "PRESSURE\n",
      "8664480\n",
      "PRESSURE\n",
      "8665134\n",
      "PRESSURE\n",
      "8664594\n",
      "PRESSURE\n",
      "8665058\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[169], line 36\u001b[0m\n\u001b[1;32m     32\u001b[0m payload \u001b[38;5;241m=\u001b[39m [\u001b[38;5;241m0xD0\u001b[39m, address, \u001b[38;5;241m0x06\u001b[39m, \u001b[38;5;241m1\u001b[39m, value]\n\u001b[1;32m     33\u001b[0m dev\u001b[38;5;241m.\u001b[39mwrite(payload)\n\u001b[0;32m---> 36\u001b[0m \u001b[43mtime\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msleep\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m0.1\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m     37\u001b[0m \u001b[38;5;66;03m# write byte \u001b[39;00m\n\u001b[1;32m     39\u001b[0m value \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m0b0\u001b[39m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "# write byte\n",
    "\n",
    "address = 0x77\n",
    "\n",
    "\n",
    "# payload = [0xD0, address, 0x06, 1, 0b00011110]\n",
    "# dev.write(payload)\n",
    "# time.sleep(0.2)\n",
    "\n",
    "\n",
    "value = 0b10100110\n",
    "value = 0xa6\n",
    "\n",
    "\n",
    "for value in range(0xa0, 0xae, 2):\n",
    "    payload = [0xd0, address, 0x06, 1, value]\n",
    "    dev.write(payload)\n",
    "\n",
    "    payload = [0xc2, address, 0x06, 2, 0]\n",
    "    dev.write(payload)\n",
    "\n",
    "    d = dev.read(0xde, 100)\n",
    "    d = d[2:d[1]+2]\n",
    "    data = d[0] << 8 | d[1]\n",
    "    print(hex(value), data)\n",
    "\n",
    "\n",
    "while True:\n",
    "    # write byte \n",
    "    value = 0b01001000\n",
    "\n",
    "    payload = [0xD0, address, 0x06, 1, value]\n",
    "    dev.write(payload)\n",
    "\n",
    "\n",
    "    time.sleep(0.1)\n",
    "    # write byte \n",
    "\n",
    "    value = 0b0\n",
    "\n",
    "    payload = [0xD0, address, 0x06, 1, 0]\n",
    "    dev.write(payload)\n",
    "\n",
    "\n",
    "    time.sleep(0.1)\n",
    "\n",
    "    payload = [0xc2, address, 0x06, 3]\n",
    "    dev.write(payload)\n",
    "    data = dev.read(0xde)\n",
    "\n",
    "    print(\"PRESSURE\")\n",
    "    data = data[2:data[1]+2]\n",
    "    data_var = data[0] << 16 | data[1] << 8 | data[2]\n",
    "    print(data_var)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [],
   "source": [
    "class read():\n",
    "    VID = 0x0403\n",
    "    PID = 0x6030\n",
    "    VID = 0x1209    \n",
    "    PID = 0x7aa0\n",
    "    I2C_INTERFACE = 0\n",
    "\n",
    "    def __init__(self):\n",
    "        self.dev = hid.device()\n",
    "        self.dev.open(self.VID, self.PID)\n",
    "        print(\"Connected to HID device\", self.dev)\n",
    "\n",
    "\n",
    "        self.dev.send_feature_report([0xA1, 0x20])\n",
    "        self.dev.send_feature_report([0xA1, 0x02, 0x01])\n",
    "\n",
    "        self.ftdi = FT260HidDriver(0, self.dev)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Device manufacturer: FTDI\n",
      "Product: FT260\n",
      "Serial Number: Љ\n",
      "Nastavit speed na 100 Hz:  0x64 0x0\n",
      "Status\n",
      "{'busy_chip': 0, 'error': 0, 'no_ack': 0, 'arbitration_lost': 0, 'idle': 0, 'busy_bus': 1, 'baudrate': 100000}\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    dev.close()\n",
    "except:\n",
    "    pass\n",
    "\n",
    "\n",
    "dev = hid.device()\n",
    "dev.open(0x1209, 0x7aa0)\n",
    "\n",
    "\n",
    "def initialize_ftdi():\n",
    "    # TODO pripojeni k HID, nyni to mam jako dev\n",
    "\n",
    "    print(f'Device manufacturer: {dev.get_manufacturer_string()}')\n",
    "    print(f'Product: {dev.get_product_string()}')\n",
    "    print(f'Serial Number: {dev.get_serial_number_string()}')\n",
    "\n",
    "    dev.set_nonblocking(0)\n",
    "\n",
    "    speed = int(100)\n",
    "    LSB = (speed & 0xff)\n",
    "    MSB = (speed>>8 & 0xff)\n",
    "    print(f\"Nastavit speed na {speed} Hz: \", hex(LSB), hex(MSB))\n",
    "    dev.send_feature_report([0xA1, 0x22, LSB, MSB])\n",
    "\n",
    "\n",
    "#self.reset_i2c()\n",
    "#self.set_i2c_speed(100000) # 100 Khz\n",
    "#self.get_i2c_status()\n",
    "\n",
    "\n",
    "def get_i2c_status():\n",
    "    d = dev.get_feature_report(0xC0, 100)\n",
    "\n",
    "    status = ['busy_chip', 'error', 'no_ack', 'arbitration_lost', 'idle', 'busy_bus']\n",
    "    bits = [(d[1] & (1 << i)) >> i for i in range(8)]\n",
    "    status = dict(zip(status, bits))\n",
    "\n",
    "    baudrate = (d[2] | d[3]<<8)*1000\n",
    "    status['baudrate'] = baudrate\n",
    "\n",
    "    print(\"Status\")\n",
    "    print(status)\n",
    "    #return status\n",
    "\n",
    "\n",
    "initialize_ftdi()\n",
    "get_i2c_status()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "# c.write_byte_data(addr_switch, 0x01, 0x03)\n",
    "dev.write([0xD0, 0x70, 0x06, 2, 0x01, 0x03])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Length 16\n",
      "['0xd3', '0x10', '0x12', '0x90', '0xc0', '0x8', '0x6', '0xa2', '0x0', '0x91', '0x9c', '0x49', '0xa0', '0x0', '0xa0', '0x0', '0x0', '0x9c', '0xff', '0xff']\n",
      "0x1290c00806a200919c49a000a000009c\n"
     ]
    }
   ],
   "source": [
    "address = 0x58\n",
    "register = 8\n",
    "\n",
    "\n",
    "register = (0x08).to_bytes(2, byteorder='little')\n",
    "payload = [0xD4, address, 0x02, 2, register[0], register[1]]\n",
    "dev.write(payload)\n",
    "length = (16).to_bytes(2, byteorder='little')\n",
    "dev.write([0xC2, address, 0x07, length[0], length[1]])\n",
    "d = dev.read(0xde, 1000)\n",
    "\n",
    "print(\"Length\", d[1])\n",
    "print([hex(x) for x in d])\n",
    "data = 0\n",
    "for da in d[2:d[1]+2]:\n",
    "    data = data << 8 | da\n",
    "print(hex(data))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[209, 6, 101, 233, 234, 60, 178, 90, 255, 255, 255, 255]\n"
     ]
    }
   ],
   "source": [
    "# Cteni z SHT\n",
    "\n",
    "temperature_cmd = [0x24, 0x00] \n",
    "address = 0x44\n",
    "\n",
    "register = (0x08).to_bytes(2, byteorder='little')\n",
    "payload = [0xD4, address, 0x06, 2, temperature_cmd[0], temperature_cmd[1]]\n",
    "dev.write(payload)\n",
    "time.sleep(0.2)\n",
    "length = (6).to_bytes(2, byteorder='little')\n",
    "dev.write([0xC2, address, 0x06, length[0], length[1]])\n",
    "d = dev.read(0xde, 1000)\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Length 16\n",
      "['0xd3', '0x10', '0xff', '0xff', '0xff', '0xff', '0xff', '0xff', '0xff', '0xff', '0xff', '0xff', '0xff', '0xff', '0xff', '0xff', '0xff', '0xff', '0xff', '0xff']\n",
      "0xffffffffffffffffffffffffffffffff\n"
     ]
    }
   ],
   "source": [
    "address = 0x53\n",
    "register = 10\n",
    "length = 16\n",
    "\n",
    "\n",
    "register = (0x08).to_bytes(2, byteorder='little')\n",
    "payload = [0xD4, address, 0x02, 2, register[0], register[1]]\n",
    "dev.write(payload)\n",
    "length = (length).to_bytes(2, byteorder='little')\n",
    "dev.write([0xC2, address, 0x07, length[0], length[1]])\n",
    "d = dev.read(0xde, 1000)\n",
    "\n",
    "\n",
    "\n",
    "print(\"Length\", d[1])\n",
    "print([hex(x) for x in d])\n",
    "data = 0\n",
    "for da in d[2:d[1]+2]:\n",
    "    data = data << 8 | da\n",
    "print(hex(data))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "address = 0x50\n",
    "register = 5\n",
    "\n",
    "data = [0xA, 0xB, 0xC, 0xD, 0xE, 0xF, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x1, 0x1, 0x2]\n",
    "\n",
    "register = (0x08).to_bytes(2, byteorder='little')\n",
    "payload = [0xD4, address, 0x02, 2, register[0], register[1]]\n",
    "dev.write(payload)\n",
    "length = (len(data)).to_bytes(2, byteorder='little')\n",
    "dev.write([0xDF, address, 0x07, length[0], length[1]]+ data)\n",
    "d = dev.read(0xde, 1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Status\n",
      "{'busy_chip': 0, 'error': 0, 'no_ack': 0, 'arbitration_lost': 0, 'idle': 0, 'busy_bus': 1, 'baudrate': 100000}\n",
      "> -1\n",
      "> -1\n",
      "[]\n",
      "Status\n",
      "{'busy_chip': 0, 'error': 0, 'no_ack': 0, 'arbitration_lost': 0, 'idle': 0, 'busy_bus': 1, 'baudrate': 100000}\n",
      "0x0\n"
     ]
    }
   ],
   "source": [
    "# S Addr Wr [A] Comm [A] \n",
    "#                          Sr Addr Rd [A] [Data] A [Data] A ... A [Data] NA P\n",
    "\n",
    "get_i2c_status()\n",
    "addr = 0x58\n",
    "\n",
    "#dev.send_feature_report([0xA1, 0x40])\n",
    "\n",
    "# Read request\n",
    "r = dev.write([\n",
    "    0xD2, addr, 0x02, 2, 0x00, 0x00\n",
    "])\n",
    "time.sleep(0.3)\n",
    "print(\">\", r)\n",
    "r = dev.write([\n",
    "    0xC2, addr, 0x03, 16, 0 \n",
    "])\n",
    "\n",
    "time.sleep(0.3)\n",
    "#d = dev.read(100, 1000)\n",
    "d = dev.read(20, 500)\n",
    "\n",
    "print(\">\", r)\n",
    "\n",
    "\n",
    "time.sleep(0.1)\n",
    "print(d)\n",
    "get_i2c_status()\n",
    "\n",
    "sn = 0\n",
    "for b in d:\n",
    "    sn = (sn << 8) | b\n",
    "print(hex(sn))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Status\n",
      "{'busy_chip': 0, 'error': 0, 'no_ack': 0, 'arbitration_lost': 0, 'idle': 0, 'busy_bus': 1, 'baudrate': 100000}\n"
     ]
    },
    {
     "ename": "OSError",
     "evalue": "read error",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mOSError\u001b[0m                                   Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[11], line 15\u001b[0m\n\u001b[1;32m     10\u001b[0m \u001b[38;5;66;03m# dev.write([\u001b[39;00m\n\u001b[1;32m     11\u001b[0m \u001b[38;5;66;03m#     0xC2, addr, 0x03, 2, 0\u001b[39;00m\n\u001b[1;32m     12\u001b[0m \u001b[38;5;66;03m# ])\u001b[39;00m\n\u001b[1;32m     14\u001b[0m time\u001b[38;5;241m.\u001b[39msleep(\u001b[38;5;241m0.1\u001b[39m)\n\u001b[0;32m---> 15\u001b[0m d \u001b[38;5;241m=\u001b[39m \u001b[43mdev\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mread\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m0xff\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m     16\u001b[0m \u001b[38;5;28mprint\u001b[39m(d)\n\u001b[1;32m     18\u001b[0m sn \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m0\u001b[39m\n",
      "File \u001b[0;32mhid.pyx:234\u001b[0m, in \u001b[0;36mhid.device.read\u001b[0;34m()\u001b[0m\n",
      "\u001b[0;31mOSError\u001b[0m: read error"
     ]
    }
   ],
   "source": [
    "get_i2c_status()\n",
    "addr = 0x44\n",
    "dev.write([\n",
    "    0xD0, addr, 0x02, 2, 0x24, 0x00,0x00\n",
    "])\n",
    "dev.write([\n",
    "    0xC2, addr, 0x07, 2, 0x24, 0x00\n",
    "])\n",
    "time.sleep(0.1)\n",
    "# dev.write([\n",
    "#     0xC2, addr, 0x03, 2, 0\n",
    "# ])\n",
    "\n",
    "time.sleep(0.1)\n",
    "d = dev.read(0xff)\n",
    "print(d)\n",
    "\n",
    "sn = 0\n",
    "for b in d:\n",
    "    sn = (sn << 8) | b\n",
    "print(hex(sn))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}