WebSVN – freemyipod – Diff – /embios/trunk/tools/libembios.py

         self.update(state)
         self.__dict__ = self
 class Embios(object):
+    """
+        Class for all embios functions.
+    """
     def __init__(self):
-        self.lib = Lib(self)
+        self.lib = Lib()
+        self.getpacketsizeinfo()
     @staticmethod
     def _alignsplit(addr, size, blksize, align):
         end = addr + size
         if addr & (align - 1):
     def read(self, addr, size):
         """ Reads the memory from location 'addr' with size 'size'
             from the device. This cares about too long packages
             and decides whether to use DMA or not.
         """
-        if not self.lib.connected:
-            self.lib.connect()
-        cin_maxsize = self.lib.dev.packetsizelimit["cin"] - 0x10
+        cin_maxsize = self.lib.dev.packetsizelimit["cin"] - self.lib.headersize
         din_maxsize = self.lib.dev.packetsizelimit["din"]
         data = ""
         (headsize, bodysize, tailsize) = self._alignsplit(addr, size, cin_maxsize, 16)
         if headsize != 0:
             data += self.readmem(addr, headsize)
     def write(self, addr, data):
         """ Writes the data in 'data' to the location 'addr'
             in the memory of the device. This cares about too long packages
             and decides whether to use DMA or not.
         """
-        if not self.lib.connected:
-            self.lib.connect()
-        cout_maxsize = self.lib.dev.packetsizelimit["cout"] - 0x10
+        cout_maxsize = self.lib.dev.packetsizelimit["cout"] - self.lib.headersize
         dout_maxsize = self.lib.dev.packetsizelimit["dout"]
         (headsize, bodysize, tailsize) = self._alignsplit(addr, len(data), cout_maxsize, 16)
         offset = 0
         if headsize != 0:
             self.writemem(addr, headsize)
     def readstring(self, addr, maxlength = 256):
         """ Reads a zero terminated string from memory
             Reads only a maximum of 'maxlength' chars.
         """
-        cin_maxsize = self.lib.dev.packetsizelimit["cin"] - 0x10
+        cin_maxsize = self.lib.dev.packetsizelimit["cin"] - self.lib.headersize
         string = ""
         while (len(string) < maxlength or maxlength < 0):
             data = self.readmem(addr, min(maxlength - len(string), cin_maxsize))
             length = data.find("\0")
             if length >= 0:
             addr += cin_maxsize
         return string
     def i2cread(self, index, slaveaddr, startaddr, size):
         """ Reads data from an i2c slave """
+        if size > 256 or size < 1:
+            raise ValueError("Size must be a number between 1 and 256")
+        if size == 256:
+            size = 0
+        resp = self.lib.monitorcommand(struct.pack("IBBBBII", 8, index, slaveaddr, startaddr, size, 0, 0), "III%ds" % size, (None, None, None, "data"))
+        return resp.data
     def i2cwrite(self, index, slaveaddr, startaddr, data):
         """ Writes data to an i2c slave """
+        size = len(data)
+        if size > 256 or size < 1:
+            raise ValueError("Size must be a number between 1 and 256")
+        if size == 256:
+            size = 0
+        return self.lib.monitorcommand(struct.pack("IBBBBII%ds" % size, 9, index, slaveaddr, startaddr, size, 0, 0, data), "III" % size, (None, None, None))
-    def usbcread(self, size):
+    def usbcread(self):
-        """ Reads data with size 'size' from the USB console """
+        """ Reads one packet with the maximal cin size """
+        cin_maxsize = self.lib.dev.packetsizelimit["cin"] - self.lib.headersize
+        resp = self.lib.monitorcommand(struct.pack("IIII", 10, cin_maxsize, 0, 0), "III%ds" % cin_maxsize, ("validsize", "buffersize", "queuesize", "data"))
+        resp.data = resp.data[:resp.validsize]
+        resp.maxsize = cin_maxsize
+        return resp
     def usbcwrite(self, data):
         """ Writes data to the USB console """
+        cin_maxsize = self.lib.dev.packetsizelimit["cin"] - self.lib.headersize
+        size = len(data)
+        while len(data) > 0:
+            writesize = min(cin_maxsize, len(data))
+            resp = self.lib.monitorcommand(struct.pack("IIII%ds" % writesize, 11, writesize, 0, 0, data[:writesize]), "III", ("validsize", "buffersize", "freesize"))
+            data = data[resp.validsize:]
+        return size
-    def cread(self, size, bitmask):
+    def cread(self, bitmask=0x1):
-        """ Reads data with the specified size from the device consoles
+        """ Reads one packet with the maximal cin size from the device consoles
             identified with the specified bitmask
         """
+        cin_maxsize = self.lib.dev.packetsizelimit["cin"] - self.lib.headersize
+        resp = self.lib.monitorcommand(struct.pack("IIII", 14, cin_maxsize, 0, 0), "III%ds" % cin_maxsize, ("size", None, None))
+        resp.data = resp.data[size:]
+        resp.maxsize = cin_maxsize
+        return resp
-    def cwrite(self, data):
+    def cwrite(self, data, bitmask=0x1):
         """ Writes data to the device consoles
             identified with the specified bitmask.
         """
+        cin_maxsize = self.lib.dev.packetsizelimit["cin"] - self.lib.headersize
+        size = len(data)
+        while len(data) > 0:
+            writesize = min(cin_maxsize, len(data))
+            resp = self.lib.monitorcommand(struct.pack("IIII%ds" % writesize, 13, writesize, 0, 0, data[:writesize]), "III", (None, None, None))
+            data = data[writesize:]
+        return size
     def cflush(self, bitmask):
         """ Flushes the consoles specified with 'bitmask' """
         return self.lib.monitorcommand(struct.pack("IIII", 14, bitmask, 0, 0), "III", (None, None, None))
     def getprocinfo(self):
         """ Gets current state of the scheduler """
-        cin_maxsize = self.lib.dev.packetsizelimit["cin"] - 0x10
+        cin_maxsize = self.lib.dev.packetsizelimit["cin"] - self.lib.headersize
         # Get the size
         schedulerstate = self.lockscheduler()
         resp = self.lib.monitorcommand(struct.pack("IIII", 15, 0, 0, 0), "III", ("structver", "tablesize", None))
         tablesize = resp.tablesize
         size = tablesize
         if threadtype == "user":
             threadtype = 0
         elif threadtype == "system":
             threadtype = 1
         else:
-            raise SyntaxError("Threadtype must be either 'system' or 'user'")
+            raise ValueError("Threadtype must be either 'system' or 'user'")
         if priority > 256 or priority < 0:
-            raise SyntaxError("Priority must be a number between 0 and 256")
+            raise ValueError("Priority must be a number between 0 and 256")
         if state == "ready":
             state = 0
         elif state == "suspended":
             state = 1
         else:
-            raise SyntaxError("State must be either 'ready' or 'suspended'")
+            raise ValueError("State must be either 'ready' or 'suspended'")
         resp = self.lib.monitorcommand(struct.pack("IIIIIIII", 19, nameptr, entrypoint, stackptr, stacksize, threadtype, priority, state), "III", (id, None, None))
         if resp.id < 0:
             raise DeviceError("The device returned the error code "+str(resp.id))
         return resp
         """ Generates a HMAC-SHA1 hash of the buffer and saves it to 'destination' """
         return self.lib.monitorcommand(struct.pack("IIII", 26, addr, size, destination), "III", (None, None, None))
 class Lib(object):
-    def __init__(self, embios):
+    def __init__(self):
         self.idVendor = 0xFFFF
         self.idProduct = 0xE000
-        self.embios = embios
+        self.headersize = 0x10
-        self.connected = False
+        self.connect()
     def connect(self):
         self.dev = Dev(self.idVendor, self.idProduct)
         self.connected = True
-        self.embios.getpacketsizeinfo()
     def monitorcommand(self, cmd, rcvdatatypes=None, rcvstruct=None):
-        if not self.connected:
-            self.connect()
         self.dev.cout(cmd)
         if rcvdatatypes:
             rcvdatatypes = "I" + rcvdatatypes # add the response
             data = self.dev.cin(struct.calcsize(rcvdatatypes))
             data = struct.unpack(rcvdatatypes, data)
         self.idVendor = idVendor
         self.idProduct = idProduct
         self.interface = 0
         self.timeout = 100
         self.connect()
         self.findEndpoints()
         self.packetsizelimit = {}
         self.packetsizelimit['cout'] = None
         pass
     def send(self, endpoint, data):
         size = self.dev.write(endpoint, data, self.interface, self.timeout)
         if size != len(data):
-            raise SendError
+            raise SendError("Not all data was written!")
         return len
     def receive(self, endpoint, size):
         read = self.dev.read(endpoint, size, self.interface, self.timeout)
         if len(read) != size:
-            raise ReceiveError
+            raise ReceiveError("Requested size and read size don't match!")
         return read
     def cout(self, data):
         if self.packetsizelimit['cout'] and len(data) > self.packetsizelimit['cout']:
             raise SendError("Packet too big")

Subversion Repositories freemyipod

(root)/embios/trunk/tools/libembios.py @ 176 – Rev 174 → 176