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

         try:
             self.embios = libembios.Embios()
         except libembios.DeviceNotFoundError:
             self.logger.error("No emBIOS device found!")
             end(1)
+        try:
-        self.getinfo("version")
+            self.getinfo("version")
+        except libembios.DeviceNotFoundError:
+                self.logger.error("Device not found!")
+                exit(2)
     def _parsecommand(self, func, args):
         # adds self to the commandline args.
         # this is needed because the functions need access to their class.
         args.insert(0, self)
                 usage("Syntax Error in function '" + func + "'")
             except ArgumentTypeError, e:
                 usage(e)
             except NotImplementedError:
                 self.logger.error("This function is not implemented yet!")
-            except libembios.DeviceNotFoundError:
-                self.logger.error("Device not found!")
             except libembios.DeviceError, e:
                 self.logger.error(str(e))
             except TypeError, e:
                 if str(e).split(" ", 1)[0] == func + "()":
                     self.logger.error(usage("Argument Error in '" + func + "': Wrong argument count", specific=func))
             for item in values:
                 expected += "'" + item + "', "
             expected = expected[:-2]
             raise ArgumentTypeError("one out of " + expected, "'" + string + "'")
+    @staticmethod
+    def _hex(integer):
+        return "0x%x" % integer
     @command
     def getinfo(self, infotype):
         """
             Get info on the running emBIOS.
         elif infotype == "packetsize":
             resp = self.embios.getpacketsizeinfo()
             self.logger.info("Maximum packet sizes: "+str(resp))
         elif infotype == "usermemrange":
             resp = self.embios.getusermemrange()
-            self.logger.info("The user memory range is "+hex(resp.lower)+" - "+hex(resp.upper-1))
+            self.logger.info("The user memory range is "+self._hex(resp.lower)+" - "+self._hex(resp.upper-1))
         else:
             raise ArgumentTypeError("one out of 'version', 'packetsize', 'usermemrange'", infotype)
     @command
     def reset(self, force=False):
         addr = self._hexint(addr)
         try:
             f = open(filename, 'rb')
         except IOError:
             raise ArgumentError("File not readable. Does it exist?")
-        self.logger.info("Writing file '"+filename+"' to memory at "+hex(addr)+"...")
+        self.logger.info("Writing file '"+filename+"' to memory at "+self._hex(addr)+"...")
         with f:
             self.embios.write(addr, f.read())
         self.logger.info("done\n")
         size = self._hexint(size)
         try:
             f = open(filename, 'wb')
         except IOError:
             raise ArgumentError("Can not open file for write!")
-        self.logger.info("Reading data from address "+hex(addr)+" with the size "+hex(size)+" to '"+filename+"'...")
+        self.logger.info("Reading data from address "+self._hex(addr)+" with the size "+self._hex(size)+" to '"+filename+"'...")
         with f:
             f.write(self.embios.read(addr, size))
         self.logger.info("done\n")
     @command
         integer = self._hexint(integer)
         if integer > 0xFFFFFFFF:
             raise ArgumentError("Specified integer too long")
         data = chr(integer)
         self.embios.writemem(addr, data)
-        self.logger.info("Integer '"+hex(integer)+"' written successfully to "+hex(addr))
+        self.logger.info("Integer '"+self._hex(integer)+"' written successfully to "+self._hex(addr))
     @command
     def downloadint(self, addr):
         """
             Downloads a single integer from the device and prints it to the console window
             <offset>: the address to download the integer from
         """
         addr = self._hexint(addr)
         data = self.embios.readmem(addr, 1)
         integer = ord(data)
-        self.logger.info("Integer '"+hex(integer)+"' read from address "+hex(addr))
+        self.logger.info("Integer '"+self._hex(integer)+"' read from address "+self._hex(addr))
     @command
     def i2crecv(self, bus, slave, addr, size):
         """
             Reads data from an I2C device
     def writeusbconsole_file(self, file, offset=0, length=None):
         """
             Writes the file <file> to the USB console.
             Optional params <offset> <length>: specify the range in <file> to write
         """
-        # We don't care about file here, this is done when opening it
         offset = self._hexint(offset)
         length = self._hexint(length)
         raise NotImplementedError
     @command
         """
             Writes the file <file> to the device consoles specified by <bitmask>
             Optional params <offset> <length>: specify the range in <file> to write
         """
         bitmask = self._hexint(bitmask)
-        # We don't care about file here, this is done when opening it
         offset = self._hexint(offset)
         length = self._hexint(length)
         raise NotImplementedError
     @command
     @command
     def getprocinfo(self):
         """
             Fetches data on the currently running processes
-            ATTENTION: this function will be print the information to the console window.
-                If several threads are running this might overflow the window,
-                causing not everything to be shown.
         """
+        import datetime
+        threads = self.embios.getprocinfo()
+        self.logger.info("The device has "+str(len(threads))+" running threads:\n\n")
+        for thread in threads:
+            self.logger.info("  "+thread.name+":\n")
+            self.logger.info("    Thread id: "+str(thread.id)+"\n")
+            self.logger.info("    Thread type: "+thread.type+"\n")
+            self.logger.info("    Thread state: "+thread.state+"\n")
+            self.logger.info("    Priority: "+str(thread.priority)+"/256\n")
+            self.logger.info("    CPU time (total): "+str(datetime.timedelta(microseconds=thread.cputime_total))+"\n")
+            self.logger.info("    Stack address: "+self._hex(thread.stackaddr)+"\n")
+            self.logger.info("    Registers:\n")
+            for register in range(16):
+                self.logger.info("      r"+str(register)+": "+self._hex(thread.regs["r"+str(register)])+"\n")
+            self.logger.info("      cpsr: "+self._hex(thread.regs.cpsr))
-        raise NotImplementedError
+            self.logger.info("\n")
     @command
     def lockscheduler(self):
         """
             Locks (freezes) the scheduler
         """
-        raise NotImplementedError
+        self.embios.lockscheduler()
     @command
     def unlockscheduler(self):
         """
             Unlocks (unfreezes) the scheduler
         """
-        raise NotImplementedError
+        self.embios.unlockscheduler()
     @command
     def suspendthread(self, threadid):
         """
             Suspends/resumes the thread with thread ID <threadid>
         """
         threadid = self._hexint(threadid)
-        raise NotImplementedError
+        self.embios.resumethread(threadid)
     @command
     def resumethread(self, threadid):
         """
             Resumes the thread with thread ID <threadid>
         """
         threadid = self._hexint(threadid)
-        raise NotImplementedError
+        self.embios.resumethread(threadid)
     @command
     def killthread(self, threadid):
         """
             Kills the thread with thread ID <threadid>
         """
         threadid = self._hexint(threadid)
-        raise NotImplementedError
+        self.embios.killthread(threadid)
     @command
     def createthread(self, nameptr, entrypoint, stackptr, stacksize, threadtype, priority, state):
         """
             Creates a new thread and returns its thread ID
         self.embios.createthread(nameptr, entrypoint, stackptr, stacksize, type, priority, state)
     @command
     def run(self, filename):
         """
-            Uploads the emBIOS application to an address in the user memory
+            Uploads the emBIOS application <filename> to
-            and executes it
+            the beginning of the user memory and executes it
         """
         try:
             f = open(filename, "rb")
         except IOError:
             raise ArgumentError("File not readable. Does it exist?")
         addr = data.lower
         maxsize = data.upper - data.lower
         filesize = os.path.getsize(filename)
         if filesize > maxsize:
             raise ArgumentError("The file is too big, it doesn't fit into the user memory.")
-        self.logger.info("Uploading application to "+hex(addr)+" - "+hex(addr+filesize)+"\n")
+        self.logger.info("Uploading application to "+self._hex(addr)+" - "+self._hex(addr+filesize)+"\n")
         self.embios.write(addr, f.read())
-        self.execute(addr)
+        self.execimage(addr)
     @command
-    def execute(self, addr):
+    def execimage(self, addr):
         """
-            Executes the emBIOS application at <address>.
+            Executes the emBIOS application at <addr>.
         """
         addr = self._hexint(addr)
-        self.logger.info("Starting emBIOS app at "+hex(addr)+"\n")
+        self.logger.info("Starting emBIOS app at "+self._hex(addr)+"\n")
         self.embios.execimage(addr)
     @command
     def readrawbootflash(self, addr_flash, addr_mem, size):
         """
         """
         addr = self._hexint(addr)
         size = self._hexint(size)
         destination = self._hexint(destination)
         sha1size = 0x14
-        self.logger.info("Generating hmac-sha1 hash from the buffer at "+hex(addr)+" with the size "+hex(size)+
+        self.logger.info("Generating hmac-sha1 hash from the buffer at "+self._hex(addr)+" with the size "+self._hex(size)+
-                         " and saving it to "+hex(destination)+" - "+hex(destination+sha1size)+"...")
+                         " and saving it to "+self._hex(destination)+" - "+self._hex(destination+sha1size)+"...")
         self.embios.hmac_sha1(addr, size, destination)
         self.logger.info("done\n")
         data = self.embios.readmem(destination, sha1size)
         hash = ord(data)
-        self.logger.info("The generated hash is "+hex(hash))
+        self.logger.info("The generated hash is "+self._hex(hash))
 if __name__ == "__main__":
     if len(sys.argv) < 2:
         usage("No command specified")
     interface = Commandline()

Subversion Repositories freemyipod

(root)/embios/trunk/tools/embios.py @ 173 – Rev 172 → 173