mbedAPI.cpp

00001 // mbedAPI.cpp 2015/5/22
00002 #include <algorithm>
00003 #include "mbed.h"
00004 #include "mbedAPI.h"
00005 #include "PinNameTable.h"
00006 
00007 // $MBEDAPI
00008 #define mbed_wait           1
00009 #define mbed_wait_ms        2
00010 #define mbed_DigitalOut     3
00011 #define mbed_DigitalIn      4
00012 #define mbed_DigitalInOut   5
00013 #define mbed_Timer          6
00014 #define mbed_RawSerial      7
00015 #define mbed_read           8
00016 #define mbed_write          9
00017 #define mbed_putc           10
00018 #define mbed_getc           11
00019 #define mbed_readable       12
00020 #define mbed_baud           13
00021 #define mbed_SPI            14
00022 #define mbed_I2C            15
00023 #define mbed_start          16
00024 #define mbed_stop           17
00025 #define mbed_reset          18
00026 #define mbed_read_ms        19
00027 #define mbed_read_us        20
00028 #define mbed_PwmOut         21
00029 #define mbed_period_ms      22
00030 #define mbed_period_us      23
00031 #define mbed_pulsewidth_ms  24
00032 #define mbed_pulsewidth_us  25
00033 #define mbed_AnalogIn       26
00034 #define mbed_read_u16       27
00035 
00036 void mbedAPI::code() {
00037     int f = ips.pull_ps();
00038     uint16_t a1;
00039     switch(f) {
00040         case mbed_wait_ms:
00041             a1 = ips.pull_ps();
00042             wait_ms(a1);
00043             break;
00044         case mbed_Timer:
00045             init<Timer>(f);
00046             break;
00047         case mbed_DigitalOut:
00048             init<DigitalOut, PinName>(f);
00049             break;
00050         case mbed_DigitalIn:
00051             init<DigitalIn, PinName>(f);
00052             break;
00053         case mbed_DigitalInOut:
00054             init<DigitalInOut, PinName>(f);
00055             break;
00056         case mbed_AnalogIn:
00057             init<AnalogIn, PinName>(f);
00058             break;
00059         case mbed_PwmOut:
00060             init<PwmOut, PinName>(f);
00061             break;
00062         case mbed_RawSerial:
00063             init<RawSerial, PinName, PinName>(f);
00064             break;
00065         case mbed_SPI:
00066             init<SPI, PinName, PinName, PinName>(f);
00067             break;
00068         case mbed_I2C:
00069             init<I2C, PinName, PinName>(f);
00070             break;
00071         default:
00072             code_method(f);
00073             break;
00074     }
00075 }
00076 
00077 void mbedAPI::code_method(int f) {
00078     mbedObj obj = pull_ps_obj();
00079     uint16_t a1;
00080     switch(obj.ct) {
00081         case mbed_DigitalOut:
00082             switch(f) {
00083                 case mbed_write:
00084                     method<DigitalOut, int, &DigitalOut::write>(obj.p);
00085                     break;
00086                 case mbed_read:
00087                     method<int, DigitalOut, &DigitalOut::read>(obj.p);
00088                     break;
00089                 default:
00090                     break;
00091             }
00092             break;
00093         case mbed_DigitalInOut:
00094             switch(f) {
00095                 case mbed_write:
00096                     method<DigitalInOut, int, &DigitalInOut::write>(obj.p);
00097                     break;
00098                 case mbed_read:
00099                     method<int, DigitalInOut, &DigitalInOut::read>(obj.p);
00100                     break;
00101                 default:
00102                     break;
00103             }
00104             break;
00105         case mbed_AnalogIn:
00106             switch(f) {
00107                 case mbed_read_u16:
00108                     method<unsigned short, AnalogIn, &AnalogIn::read_u16>(obj.p);
00109                     break;
00110                 default:
00111                     error("%s %d", __LINE__, f);
00112                     break;
00113             }
00114             break;
00115         case mbed_PwmOut:
00116             switch(f) {
00117                 case mbed_period_ms:
00118                     method<PwmOut, int, &PwmOut::period_ms>(obj.p);
00119                     break;
00120                 case mbed_period_us:
00121                     method<PwmOut, int, &PwmOut::period_us>(obj.p);
00122                     break;
00123                 case mbed_pulsewidth_ms:
00124                     method<PwmOut, int, &PwmOut::pulsewidth_ms>(obj.p);
00125                     break;
00126                 case mbed_pulsewidth_us:
00127                     method<PwmOut, int, &PwmOut::pulsewidth_us>(obj.p);
00128                     break;
00129                 default:
00130                     error("%s %d", __LINE__, f);
00131                     break;
00132             }
00133             break;
00134         case mbed_Timer:
00135             switch(f) {
00136                 case mbed_start:
00137                     method<Timer, &Timer::start>(obj.p);
00138                     break;
00139                 case mbed_stop:
00140                     method<Timer, &Timer::stop>(obj.p);
00141                     break;
00142                 case mbed_reset:
00143                     method<Timer, &Timer::reset>(obj.p);
00144                     break;
00145                 case mbed_read_ms:
00146                     method<int, Timer, &Timer::read_ms>(obj.p);
00147                     break;
00148                 case mbed_read_us:
00149                     method<int, Timer, &Timer::read_us>(obj.p);
00150                     break;
00151                 default:
00152                     error("%s %d", __LINE__, f);
00153                     break;
00154             }
00155             break;
00156         case mbed_DigitalIn:
00157             switch(f) {
00158                 case mbed_read:
00159                     method<int, DigitalIn, &DigitalIn::read>(obj.p);
00160                     break;
00161                 default:
00162                     error("%s %d", __LINE__, f);
00163                     break;
00164             }
00165             break;
00166         case mbed_SPI:
00167             switch(f) {
00168                 case mbed_write:
00169                     method<int, SPI, int, &SPI::write>(obj.p);
00170                     break;
00171                 default:
00172                     error("%s %d", __LINE__, f);
00173                     break;
00174             }
00175             break;
00176         case mbed_I2C:
00177             code_method_I2C(f, obj);
00178             break;
00179         case mbed_RawSerial:
00180             switch(f) {
00181                 case mbed_putc:
00182                     a1 = ips.pull_ps();
00183                     reinterpret_cast<RawSerial*>(obj.p)->putc(a1);
00184                     break;
00185                 case mbed_getc:
00186                     method<int, RawSerial, &RawSerial::getc>(obj.p);
00187                     break;
00188                 case mbed_readable:
00189                     ips.push_ps(reinterpret_cast<RawSerial*>(obj.p)->readable());
00190                     break;
00191                 case mbed_baud:
00192                     a1 = ips.pull_ps();
00193                     reinterpret_cast<RawSerial*>(obj.p)->baud(a1);
00194                     break;
00195                 default:
00196                     error("%s %d", __LINE__, f);
00197                     break;
00198             }
00199             break;
00200         default:
00201             break;
00202     }
00203 }
00204 
00205 void mbedAPI::code_method_I2C(int f, mbedObj& obj) {
00206     if (f == mbed_read) {
00207         uint16_t addr = ips.pull_ps();
00208         uint16_t len = ips.pull_ps();
00209         uint16_t ptr = ips.pull_ps();
00210         char buf[len];
00211         reinterpret_cast<I2C*>(obj.p)->read(addr, buf, len);
00212         for(int i = 0; i < len; i++) {
00213             ips.pokeB(ptr + i, buf[i]);
00214         }
00215     } else if (f == mbed_write) {
00216         uint16_t addr = ips.pull_ps();
00217         uint16_t len = ips.pull_ps();
00218         uint16_t ptr = ips.pull_ps();
00219         char buf[len];
00220         for(int i = 0; i < len; i++) {
00221             buf[i] = ips.peekB(ptr + i);
00222         }
00223         reinterpret_cast<I2C*>(obj.p)->write(addr, buf, len);
00224     } else {
00225         error("%s %d", __LINE__, f);
00226     }
00227 }
00228 
00229 template<>
00230 PinName mbedAPI::pull_ps<PinName>() {
00231     char buf[64];
00232     pull_ps_string(buf, sizeof(buf));
00233     return findPinName(buf);
00234 }
00235 
00236 mbedObj mbedAPI::pull_ps_obj() {
00237     int i = ips.pull_ps();
00238     return objs[i];
00239 }
00240 
00241 void mbedAPI::pull_ps_string(char* buf, size_t size) {
00242     size_t s_len = ips.pull_ps();
00243     int s_start = ips.pull_ps();
00244     s_len = std::min(s_len, size-1);
00245     for(size_t i = 0; i < s_len; i++) {
00246         buf[i] = ips.peekB(s_start + i);
00247     }
00248     buf[s_len] = '\0';
00249 }
00250 
00251 PinName mbedAPI::findPinName(const char* name) const {
00252     int imin = 0;
00253     int imax = sizeof(pinname_table) / sizeof(pinNameStr) - 1;
00254     while(imax >= imin) {
00255         int i = (imin + imax) / 2;
00256         int c = strcmp(name, pinname_table[i].name);
00257         if (c == 0) {
00258             return pinname_table[i].pin;
00259         } else if (c > 0) {
00260             imin = i + 1;
00261         } else {
00262             imax = i - 1;
00263         }
00264     }
00265     return NC;
00266 }
00267 
00268 void mbedAPI::push_ps_obj(void* p, int ct) {
00269     mbedObj obj;
00270     obj.p = p;
00271     obj.ct = ct;
00272     objs.push_back(obj);
00273     uint16_t r1 = objs.size() - 1;
00274     ips.push_ps(r1);
00275 }
00276 
00277 
00278