WebSVN – freemyipod – Diff – /emcore/trunk/tools/libemcore.py



 
import sys
import struct
import ctypes
import usb.core
import base64
 
from libemcoredata import *
from misc import Logger, Bunch, Error, ArgumentError, gethwname
from functools import wraps
 

            from the device. This cares about too long packages
            and decides whether to use DMA or not.
        """
        cin_maxsize = self.lib.dev.packetsizelimit.cin - self.lib.headersize
        din_maxsize = self.lib.dev.packetsizelimit.din
        data = b""
        (headsize, bodysize, tailsize) = self._alignsplit(addr, size, cin_maxsize, 16)
        self.logger.debug("Downloading %d bytes from 0x%X, split as (%d/%d/%d)\n" % (size, addr, headsize, bodysize, tailsize))
        if headsize != 0:
            data += self._readmem(addr, headsize)
            addr += headsize

        """
        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(b"\0")
            if length >= 0:
                string += data[:length].decode("latin_1")
                break
            else:
                string += data.decode("latin_1")
            addr += cin_maxsize
        return string
    
    @command()
    def i2cread(self, index, slaveaddr, startaddr, size):
        """ Reads data from an i2c slave """
        data = b""
        for i in range(size):
            resp = self.lib.monitorcommand(struct.pack("<IBBBBII", 8, index, slaveaddr, startaddr + i, 1, 0, 0), "III1s", (None, None, None, "data"))
            data += resp.data
        return data
    

            size = 0
        return self.lib.monitorcommand(struct.pack("<IBBBBII%ds" % size, 9, index, slaveaddr, startaddr, size, 0, 0, data), "III", (None, None, None))
    
    @command()
    def usbcread(self):
        """ Reads one packet with the maximal cin size from the console """
        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].decode("latin_1")
        resp.maxsize = cin_maxsize
        return resp
    
    @command()
    def usbcwrite(self, data):

    def connect(self):
        self.dev = Dev(self.idVendor, self.idProduct, self.logger)
        self.connected = True
    
    def monitorcommand(self, cmd, rcvdatatypes=None, rcvstruct=None):
        self.logger.debug("Sending monitorcommand [0x%s]\n" % base64.b16encode(cmd[3::-1]).decode("ascii"))
        writelen = self.dev.cout(cmd)
        if rcvdatatypes:
            rcvdatatypes = "I" + rcvdatatypes # add the response
            data = self.dev.cin(struct.calcsize(rcvdatatypes))
            data = struct.unpack(rcvdatatypes, data)

    if sys.argv[1] == "gendoc":
        # Generates Documentation
        from misc import gendoc
        logger.write("Generating documentation\n")
        cmddict = {}
        for attr, value in Emcore.__dict__.items():
            if getattr(value, 'func', False):
                if getattr(value.func, '_command', False):
                    cmddict[value.func.__name__] = value
        logger.write(gendoc(cmddict))
    

Rev 548	Rev 582
Line 28...	Line 28...
28		28
29	`import sys`	29	`import sys`
30	`import struct`	30	`import struct`
31	`import ctypes`	31	`import ctypes`
32	`import usb.core`	32	`import usb.core`
-		33	`import base64`
33		34
34	`from libemcoredata import *`	35	`from libemcoredata import *`
35	`from misc import Logger, Bunch, Error, ArgumentError, gethwname`	36	`from misc import Logger, Bunch, Error, ArgumentError, gethwname`
36	`from functools import wraps`	37	`from functools import wraps`
37		38
Line 220...	Line 221...
220	`from the device. This cares about too long packages`	221	`from the device. This cares about too long packages`
221	`and decides whether to use DMA or not.`	222	`and decides whether to use DMA or not.`
222	`"""`	223	`"""`
223	`cin_maxsize = self.lib.dev.packetsizelimit.cin - self.lib.headersize`	224	`cin_maxsize = self.lib.dev.packetsizelimit.cin - self.lib.headersize`
224	`din_maxsize = self.lib.dev.packetsizelimit.din`	225	`din_maxsize = self.lib.dev.packetsizelimit.din`
225	`data = ""`	226	`data = b""`
226	`(headsize, bodysize, tailsize) = self._alignsplit(addr, size, cin_maxsize, 16)`	227	`(headsize, bodysize, tailsize) = self._alignsplit(addr, size, cin_maxsize, 16)`
227	`self.logger.debug("Downloading %d bytes from 0x%X, split as (%d/%d/%d)\n" % (size, addr, headsize, bodysize, tailsize))`	228	`self.logger.debug("Downloading %d bytes from 0x%X, split as (%d/%d/%d)\n" % (size, addr, headsize, bodysize, tailsize))`
228	`if headsize != 0:`	229	`if headsize != 0:`
229	`data += self._readmem(addr, headsize)`	230	`data += self._readmem(addr, headsize)`
230	`addr += headsize`	231	`addr += headsize`
Line 286...	Line 287...
286	`"""`	287	`"""`
287	`cin_maxsize = self.lib.dev.packetsizelimit.cin - self.lib.headersize`	288	`cin_maxsize = self.lib.dev.packetsizelimit.cin - self.lib.headersize`
288	`string = ""`	289	`string = ""`
289	`while (len(string) < maxlength or maxlength < 0):`	290	`while (len(string) < maxlength or maxlength < 0):`
290	`data = self._readmem(addr, min(maxlength - len(string), cin_maxsize))`	291	`data = self._readmem(addr, min(maxlength - len(string), cin_maxsize))`
291	`length = data.find("\0")`	292	`length = data.find(b"\0")`
292	`if length >= 0:`	293	`if length >= 0:`
293	`string += data[:length]`	294	`string += data[:length].decode("latin_1")`
294	`break`	295	`break`
295	`else:`	296	`else:`
296	`string += data`	297	`string += data.decode("latin_1")`
297	`addr += cin_maxsize`	298	`addr += cin_maxsize`
298	`return string`	299	`return string`
299		300
300	`@command()`	301	`@command()`
301	`def i2cread(self, index, slaveaddr, startaddr, size):`	302	`def i2cread(self, index, slaveaddr, startaddr, size):`
302	`""" Reads data from an i2c slave """`	303	`""" Reads data from an i2c slave """`
303	`data = ""`	304	`data = b""`
304	`for i in range(size):`	305	`for i in range(size):`
305	`resp = self.lib.monitorcommand(struct.pack("<IBBBBII", 8, index, slaveaddr, startaddr + i, 1, 0, 0), "III1s", (None, None, None, "data"))`	306	`resp = self.lib.monitorcommand(struct.pack("<IBBBBII", 8, index, slaveaddr, startaddr + i, 1, 0, 0), "III1s", (None, None, None, "data"))`
306	`data += resp.data`	307	`data += resp.data`
307	`return data`	308	`return data`
308		309
Line 316...	Line 317...
316	`size = 0`	317	`size = 0`
317	`return self.lib.monitorcommand(struct.pack("<IBBBBII%ds" % size, 9, index, slaveaddr, startaddr, size, 0, 0, data), "III", (None, None, None))`	318	`return self.lib.monitorcommand(struct.pack("<IBBBBII%ds" % size, 9, index, slaveaddr, startaddr, size, 0, 0, data), "III", (None, None, None))`
318		319
319	`@command()`	320	`@command()`
320	`def usbcread(self):`	321	`def usbcread(self):`
321	`""" Reads one packet with the maximal cin size """`	322	`""" Reads one packet with the maximal cin size from the console """`
322	`cin_maxsize = self.lib.dev.packetsizelimit.cin - self.lib.headersize`	323	`cin_maxsize = self.lib.dev.packetsizelimit.cin - self.lib.headersize`
323	`resp = self.lib.monitorcommand(struct.pack("<IIII", 10, cin_maxsize, 0, 0), "III%ds" % cin_maxsize, ("validsize", "buffersize", "queuesize", "data"))`	324	`resp = self.lib.monitorcommand(struct.pack("<IIII", 10, cin_maxsize, 0, 0), "III%ds" % cin_maxsize, ("validsize", "buffersize", "queuesize", "data"))`
324	`resp.data = resp.data[:resp.validsize]`	325	`resp.data = resp.data[:resp.validsize].decode("latin_1")`
325	`resp.maxsize = cin_maxsize`	326	`resp.maxsize = cin_maxsize`
326	`return resp`	327	`return resp`
327		328
328	`@command()`	329	`@command()`
329	`def usbcwrite(self, data):`	330	`def usbcwrite(self, data):`
Line 916...	Line 917...
916	`def connect(self):`	917	`def connect(self):`
917	`self.dev = Dev(self.idVendor, self.idProduct, self.logger)`	918	`self.dev = Dev(self.idVendor, self.idProduct, self.logger)`
918	`self.connected = True`	919	`self.connected = True`
919		920
920	`def monitorcommand(self, cmd, rcvdatatypes=None, rcvstruct=None):`	921	`def monitorcommand(self, cmd, rcvdatatypes=None, rcvstruct=None):`
921	`self.logger.debug("Sending monitorcommand [0x%s]\n" % cmd[3::-1].encode("hex"))`	922	`self.logger.debug("Sending monitorcommand [0x%s]\n" % base64.b16encode(cmd[3::-1]).decode("ascii"))`
922	`writelen = self.dev.cout(cmd)`	923	`writelen = self.dev.cout(cmd)`
923	`if rcvdatatypes:`	924	`if rcvdatatypes:`
924	`rcvdatatypes = "I" + rcvdatatypes # add the response`	925	`rcvdatatypes = "I" + rcvdatatypes # add the response`
925	`data = self.dev.cin(struct.calcsize(rcvdatatypes))`	926	`data = self.dev.cin(struct.calcsize(rcvdatatypes))`
926	`data = struct.unpack(rcvdatatypes, data)`	927	`data = struct.unpack(rcvdatatypes, data)`
Line 1071...	Line 1072...
1071	`if sys.argv[1] == "gendoc":`	1072	`if sys.argv[1] == "gendoc":`
1072	`# Generates Documentation`	1073	`# Generates Documentation`
1073	`from misc import gendoc`	1074	`from misc import gendoc`
1074	`logger.write("Generating documentation\n")`	1075	`logger.write("Generating documentation\n")`
1075	`cmddict = {}`	1076	`cmddict = {}`
1076	`for attr, value in Emcore.__dict__.iteritems():`	1077	`for attr, value in Emcore.__dict__.items():`
1077	`if getattr(value, 'func', False):`	1078	`if getattr(value, 'func', False):`
1078	`if getattr(value.func, '_command', False):`	1079	`if getattr(value.func, '_command', False):`
1079	`cmddict[value.func.__name__] = value`	1080	`cmddict[value.func.__name__] = value`
1080	`logger.write(gendoc(cmddict))`	1081	`logger.write(gendoc(cmddict))`
1081		1082

Subversion Repositories freemyipod

(root)/emcore/trunk/tools/libemcore.py @ 582 – Rev 548 → 582