Source Code for Module nxt.brick

  1  # nxt.brick module -- Classes to represent LEGO Mindstorms NXT bricks 
  2  # Copyright (C) 2006  Douglas P Lau 
  3  # Copyright (C) 2009  Marcus Wanner 
  4  # 
  5  # This program is free software: you can redistribute it and/or modify 
  6  # it under the terms of the GNU General Public License as published by 
  7  # the Free Software Foundation, either version 3 of the License, or 
  8  # (at your option) any later version. 
  9  # 
 10  # This program is distributed in the hope that it will be useful, 
 11  # but WITHOUT ANY WARRANTY; without even the implied warranty of 
 12  # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
 13  # GNU General Public License for more details. 
 14   
 15  from time import sleep 
 16  from nxt.error import FileNotFound, ModuleNotFound 
 17  from nxt.telegram import OPCODES, Telegram 
 18   
 19 -def _make_poller(opcode, poll_func, parse_func): 
 20          def poll(self, *args, **kwargs): 
 21                  ogram = poll_func(opcode, *args, **kwargs) 
 22                  self.sock.send(str(ogram)) 
 23                  igram = Telegram(opcode=opcode, pkt=self.sock.recv()) 
 24                  return parse_func(igram) 
 25          return poll 
 26   
 27 -class _Meta(type): 
 28          'Metaclass which adds one method for each telegram opcode' 
 29   
 30 -        def __init__(cls, name, bases, dict): 
 31                  super(_Meta, cls).__init__(name, bases, dict) 
 32                  for opcode in OPCODES: 
 33                          poll_func, parse_func = OPCODES[opcode] 
 34                          m = _make_poller(opcode, poll_func, parse_func) 
 35                          setattr(cls, poll_func.__name__, m) 
 36   
 37 -class Brick(object): 
 38          'Main object for NXT Control' 
 39   
 40          __metaclass__ = _Meta 
 41   
 42 -        def __init__(self, sock): 
 43                  self.sock = sock 
 44   
 45 -        def play_tone_and_wait(self, frequency, duration): 
 46                  self.play_tone(frequency, duration) 
 47                  sleep(duration / 1000.0) 
 48   
 49 -class FileFinder(object): 
 50          'Context manager to find files on a NXT brick' 
 51   
 52 -        def __init__(self, brick, pattern): 
 53                  self.brick = brick 
 54                  self.pattern = pattern 
 55                  self.handle = None 
 56   
 57 -        def __enter__(self): 
 58                  return self 
 59   
 60 -        def __exit__(self, etp, value, tb): 
 61                  if self.handle: 
 62                          self.brick.close(self.handle) 
 63   
 64 -        def __iter__(self): 
 65                  self.handle, fname, size = self.brick.find_first(self.pattern) 
 66                  yield (fname, size) 
 67                  while True: 
 68                          try: 
 69                                  handle, fname, size = self.brick.find_next( 
 70                                          self.handle) 
 71                                  yield (fname, size) 
 72                          except FileNotFound: 
 73                                  break 
 74   
 75 -class FileReader(object): 
 76          'Context manager to read a file on a NXT brick' 
 77   
 78 -        def __init__(self, brick, fname): 
 79                  self.brick = brick 
 80                  self.fname = fname 
 81   
 82 -        def __enter__(self): 
 83                  self.handle, self.size = self.brick.open_read(self.fname) 
 84                  return self 
 85   
 86 -        def __exit__(self, etp, value, tb): 
 87                  self.brick.close(self.handle) 
 88   
 89 -        def __iter__(self): 
 90                  rem = self.size 
 91                  bsize = self.brick.sock.bsize 
 92                  while rem > 0: 
 93                          handle, bsize, data = self.brick.read(self.handle, 
 94                                  min(bsize, rem)) 
 95                          yield data 
 96                          rem -= len(data) 
 97   
 98 -class FileWriter(object): 
 99          'Context manager to write a file to a NXT brick' 
100   
101 -        def __init__(self, brick, fname, fil): 
102                  self.brick = brick 
103                  self.fname = fname 
104                  self.fil = fil 
105                  fil.seek(0, 2)  # seek to end of file 
106                  self.size = fil.tell() 
107                  fil.seek(0)     # seek to start of file 
108   
109 -        def __enter__(self): 
110                  self.handle = self.brick.open_write(self.fname, self.size) 
111                  return self 
112   
113 -        def __exit__(self, etp, value, tb): 
114                  self.brick.close(self.handle) 
115   
116 -        def __iter__(self): 
117                  rem = self.size 
118                  bsize = self.brick.sock.bsize 
119                  while rem > 0: 
120                          b = min(bsize, rem) 
121                          handle, size = self.brick.write(self.handle, 
122                                  self.fil.read(b)) 
123                          yield size 
124                          rem -= b 
125   
126 -class ModuleFinder(object): 
127          'Context manager to lookup modules on a NXT brick' 
128   
129 -        def __init__(self, brick, pattern): 
130                  self.brick = brick 
131                  self.pattern = pattern 
132                  self.handle = None 
133   
134 -        def __enter__(self): 
135                  return self 
136   
137 -        def __exit__(self, etp, value, tb): 
138                  if self.handle: 
139                          self.brick.close(self.handle) 
140   
141 -        def __iter__(self): 
142                  self.handle, mname, mid, msize, miomap_size = \ 
143                          self.brick.request_first_module(self.pattern) 
144                  yield (mname, mid, msize, miomap_size) 
145                  while True: 
146                          try: 
147                                  handle, mname, mid, msize, miomap_size = \ 
148                                          self.brick.request_next_module( 
149                                          self.handle) 
150                                  yield (mname, mid, msize, miomap_size) 
151                          except ModuleNotFound: 
152                                  break 
153