tool/mbed/mbed-sdk/workspace_tools/host_tests/mbedrpc.py

   1 """
   2 mbed SDK
   3 Copyright (c) 2010-2013 ARM Limited
   4
   5 Licensed under the Apache License, Version 2.0 (the "License");
   6 you may not use this file except in compliance with the License.
   7 You may obtain a copy of the License at
   8
   9     http://www.apache.org/licenses/LICENSE-2.0
  10
  11 Unless required by applicable law or agreed to in writing, software
  12 distributed under the License is distributed on an "AS IS" BASIS,
  13 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 See the License for the specific language governing permissions and
  15 limitations under the License.
  16
  17
  18 Example:
  19 > from mbedRPC import*
  20 > mbed = SerialRPC("COM5",9600);
  21 > myled = DigitalOut(mbed, LED1);
  22 > myled.write(1)
  23 >
  24 """
  25 import serial, urllib2, time
  26
  27
  28 class pin():
  29     def __init__(self, id):
  30         self.name = id
  31
  32 LED1 = pin("LED1")
  33 LED2 = pin("LED2")
  34 LED3 = pin("LED3")
  35 LED4 = pin("LED4")
  36
  37 p5 = pin("p5")
  38 p6 = pin("p6")
  39 p7 = pin("p7")
  40 p8 = pin("p8")
  41 p9 = pin("p9")
  42 p10 = pin("p10")
  43 p11 = pin("p11")
  44 p12 = pin("p12")
  45 p13 = pin("p13")
  46 p14 = pin("p14")
  47 p15 = pin("p15")
  48 p16 = pin("p16")
  49 p17 = pin("p17")
  50 p18 = pin("p18")
  51 p19 = pin("p19")
  52 p20 = pin("p20")
  53 p21 = pin("p21")
  54 p22 = pin("p22")
  55 p23 = pin("p23")
  56 p24 = pin("p24")
  57 p25 = pin("p25")
  58 p26 = pin("p26")
  59 p27 = pin("p27")
  60 p28 = pin("p28")
  61 p29 = pin("p29")
  62 p30 = pin("p30")
  63
  64
  65 #mbed super class
  66 class mbed:
  67     def __init__(self):
  68             print("This will work as a demo but no transport mechanism has been selected")
  69
  70     def rpc(self, name, method, args):
  71             print("Superclass method not overridden")
  72
  73 #Transport mechanisms, derived from mbed
  74
  75 class SerialRPC(mbed):
  76     def __init__(self, port, baud=9600, reset=True, debug=False):
  77         self.ser = serial.Serial(port)
  78         self.ser.setBaudrate(baud)
  79         self.ser.flushInput()
  80         self.ser.flushOutput()
  81         self.debug = debug
  82         if reset:
  83             if debug:
  84                 print "Reset mbed"
  85             self.ser.sendBreak()
  86             time.sleep(2)
  87
  88     def rpc(self, name, method, args):
  89         request = "/" + name + "/" + method + " " + " ".join(args)
  90         if self.debug:
  91             print "[RPC::TX] %s" % request
  92         self.ser.write(request + "\n")
  93
  94         while True:
  95             response = self.ser.readline().strip()
  96             if self.debug:
  97                 print "[RPC::RX] %s" % response
  98
  99             # Ignore comments
 100             if not response.startswith('#'): break
 101         return response
 102
 103
 104 class HTTPRPC(mbed):
 105     def __init__(self, ip):
 106         self.host = "http://" + ip
 107
 108     def rpc(self, name, method, args):
 109         response = urllib2.urlopen(self.host + "/rpc/" + name + "/" + method + "," + ",".join(args))
 110         return response.read().strip()
 111
 112
 113 #mbed Interfaces
 114
 115 class DigitalOut():
 116     def __init__(self, this_mbed , mpin):
 117         self.mbed = this_mbed
 118         if isinstance(mpin, str):
 119             self.name = mpin
 120         elif isinstance(mpin, pin):
 121             self.name = self.mbed.rpc("DigitalOut", "new", [mpin.name])
 122
 123     def __del__(self):
 124         r = self.mbed.rpc(self.name, "delete", [])
 125
 126     def write(self, value):
 127         r = self.mbed.rpc(self.name, "write", [str(value)])
 128
 129     def read(self):
 130         r = self.mbed.rpc(self.name, "read", [])
 131         return int(r)
 132
 133
 134 class AnalogIn():
 135     def __init__(self, this_mbed , mpin):
 136         self.mbed = this_mbed
 137         if isinstance(mpin, str):
 138             self.name = mpin
 139         elif isinstance(mpin, pin):
 140             self.name = self.mbed.rpc("AnalogIn", "new", [mpin.name])
 141
 142     def __del__(self):
 143         r = self.mbed.rpc(self.name, "delete", [])
 144
 145     def read(self):
 146         r = self.mbed.rpc(self.name, "read", [])
 147         return float(r)
 148
 149     def read_u16(self):
 150         r = self.mbed.rpc(self.name, "read_u16", [])
 151         return int(r)
 152
 153
 154 class AnalogOut():
 155     def __init__(self, this_mbed , mpin):
 156         self.mbed = this_mbed
 157         if isinstance(mpin, str):
 158             self.name = mpin
 159         elif isinstance(mpin, pin):
 160             self.name = self.mbed.rpc("AnalogOut", "new", [mpin.name])
 161
 162     def __del__(self):
 163         r = self.mbed.rpc(self.name, "delete", [])
 164
 165     def write(self, value):
 166         r = self.mbed.rpc(self.name, "write", [str(value)])
 167
 168     def write_u16(self, value):
 169         r = self.mbed.rpc(self.name, "write_u16", [str(value)])
 170
 171     def read(self):
 172         r = self.mbed.rpc(self.name, "read", [])
 173         return float(r)
 174
 175
 176 class DigitalIn():
 177     def __init__(self, this_mbed , mpin):
 178         self.mbed = this_mbed
 179         if isinstance(mpin, str):
 180             self.name = mpin
 181         elif isinstance(mpin, pin):
 182             self.name = self.mbed.rpc("DigitalIn", "new", [mpin.name])
 183
 184     def __del__(self):
 185         r = self.mbed.rpc(self.name, "delete", [])
 186
 187     def read(self):
 188         r = self.mbed.rpc(self.name, "read", [])
 189         return int(r)
 190
 191
 192 class PwmOut():
 193     def __init__(self, this_mbed , mpin):
 194         self.mbed = this_mbed
 195         if isinstance(mpin, str):
 196             self.name = mpin
 197         elif isinstance(mpin, pin):
 198             self.name = self.mbed.rpc("PwmOut", "new", [mpin.name])
 199
 200     def __del__(self):
 201         r = self.mbed.rpc(self.name, "delete", [])
 202
 203     def write(self, value):
 204         r = self.mbed.rpc(self.name, "write", [str(value)])
 205
 206     def read(self):
 207         r = self.mbed.rpc(self.name, "read", [])
 208         return float(r)
 209
 210     def period(self, value):
 211         r = self.mbed.rpc(self.name, "period", [str(value)])
 212
 213     def period_ms(self, value):
 214         r = self.mbed.rpc(self.name, "period_ms", [str(value)])
 215
 216     def period_us(self, value):
 217         r = self.mbed.rpc(self.name, "period_us", [str(value)])
 218
 219     def puslewidth(self, value):
 220         r = self.mbed.rpc(self.name, "pulsewidth", [str(value)])
 221
 222     def puslewidth_ms(self, value):
 223         r = self.mbed.rpc(self.name, "pulsewidth_ms", [str(value)])
 224
 225     def puslewidth_us(self, value):
 226         r = self.mbed.rpc(self.name, "pulsewidth_us", [str(value)])
 227
 228
 229 class Serial():
 230     def __init__(self, this_mbed , tx, rx = ""):
 231         self.mbed = this_mbed
 232         if isinstance(tx, str):
 233             self.name = mpin
 234         elif isinstance(mpin, pin):
 235             self.name = self.mbed.rpc("Serial", "new", [tx.name, rx.name])
 236
 237     def __del__(self):
 238         r = self.mbed.rpc(self.name, "delete", [])
 239
 240     def putc(self, value):
 241         r = self.mbed.rpc(self.name, "putc", [str(value)])
 242
 243     def puts(self, value):
 244         r = self.mbed.rpc(self.name, "puts", [ "\"" + str(value) + "\""])
 245
 246     def getc(self):
 247         r = self.mbed.rpc(self.name, "getc", [])
 248         return int(r)
 249
 250
 251 class RPCFunction():
 252     def __init__(self, this_mbed , name):
 253         self.mbed = this_mbed
 254         if isinstance(name, str):
 255             self.name = name
 256
 257     def __del__(self):
 258         r = self.mbed.rpc(self.name, "delete", [])
 259
 260     def read(self):
 261         r = self.mbed.rpc(self.name, "read", [])
 262         return int(r)
 263
 264     def run(self, input):
 265         r = self.mbed.rpc(self.name, "run", [input])
 266         return r
 267
 268
 269 class RPCVariable():
 270     def __init__(self, this_mbed , name):
 271         self.mbed = this_mbed
 272         if isinstance(name, str):
 273             self.name = name
 274
 275     def __del__(self):
 276         r = self.mbed.rpc(self.name, "delete", [])
 277
 278     def write(self, value):
 279         self.mbed.rpc(self.name, "write", [str(value)])
 280
 281     def read(self):
 282         r = self.mbed.rpc(self.name, "read", [])
 283         return r
 284
 285
 286 def wait(s):
 287     time.sleep(s)