STATIC mp_obj_t struct_unpack(mp_obj_t fmt_in, mp_obj_t data_in) { // TODO: "The buffer must contain exactly the amount of data required by the format (len(bytes) must equal calcsize(fmt))." const char *fmt = mp_obj_str_get_str(fmt_in); char fmt_type = get_fmt_type(&fmt); uint size = calcsize_items(fmt); mp_obj_tuple_t *res = mp_obj_new_tuple(size, NULL); mp_buffer_info_t bufinfo; mp_get_buffer_raise(data_in, &bufinfo, MP_BUFFER_READ); byte *p = bufinfo.buf; for (uint i = 0; i < size; i++) { machine_uint_t sz = 1; if (unichar_isdigit(*fmt)) { sz = get_fmt_num(&fmt); } if (sz > 1) { // TODO: size spec support only for string len assert(*fmt == 's'); } mp_obj_t item; if (*fmt == 's') { item = mp_obj_new_bytes(p, sz); p += sz; fmt++; } else { item = mp_binary_get_val(fmt_type, *fmt++, &p); } res->items[i] = item; } return res; }
/// \method calibration([pulse_min, pulse_max, pulse_centre, [pulse_angle_90, pulse_speed_100]]) /// Get or set the calibration of the servo timing. // TODO should accept 1 arg, a 5-tuple of values to set STATIC mp_obj_t pyb_servo_calibration(mp_uint_t n_args, const mp_obj_t *args) { pyb_servo_obj_t *self = args[0]; if (n_args == 1) { // get calibration values mp_obj_t tuple[5]; tuple[0] = mp_obj_new_int(10 * self->pulse_min); tuple[1] = mp_obj_new_int(10 * self->pulse_max); tuple[2] = mp_obj_new_int(10 * self->pulse_centre); tuple[3] = mp_obj_new_int(10 * (self->pulse_angle_90 + self->pulse_centre)); tuple[4] = mp_obj_new_int(10 * (self->pulse_speed_100 + self->pulse_centre)); return mp_obj_new_tuple(5, tuple); } else if (n_args >= 4) { // set min, max, centre self->pulse_min = mp_obj_get_int(args[1]) / 10; self->pulse_max = mp_obj_get_int(args[2]) / 10; self->pulse_centre = mp_obj_get_int(args[3]) / 10; if (n_args == 4) { return mp_const_none; } else if (n_args == 6) { self->pulse_angle_90 = mp_obj_get_int(args[4]) / 10 - self->pulse_centre; self->pulse_speed_100 = mp_obj_get_int(args[5]) / 10 - self->pulse_centre; return mp_const_none; } } // bad number of arguments nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "calibration expecting 1, 4 or 6 arguments, got %d", n_args)); }
STATIC mp_obj_t socket_recvfrom(size_t n_args, const mp_obj_t *args) { mp_obj_socket_t *self = MP_OBJ_TO_PTR(args[0]); int sz = MP_OBJ_SMALL_INT_VALUE(args[1]); int flags = 0; if (n_args > 2) { flags = MP_OBJ_SMALL_INT_VALUE(args[2]); } struct sockaddr_storage addr; socklen_t addr_len = sizeof(addr); byte *buf = m_new(byte, sz); int out_sz = recvfrom(self->fd, buf, sz, flags, (struct sockaddr*)&addr, &addr_len); RAISE_ERRNO(out_sz, errno); mp_obj_t buf_o = mp_obj_new_str_of_type(&mp_type_bytes, buf, out_sz); m_del(char, buf, sz); mp_obj_tuple_t *t = MP_OBJ_TO_PTR(mp_obj_new_tuple(2, NULL)); t->items[0] = buf_o; t->items[1] = mp_obj_from_sockaddr((struct sockaddr*)&addr, addr_len); return MP_OBJ_FROM_PTR(t); }
STATIC mp_obj_t listdir_next(mp_obj_t self_in) { mp_obj_listdir_t *self = MP_OBJ_TO_PTR(self_in); if (self->dir == NULL) { goto done; } struct dirent *dirent = readdir(self->dir); if (dirent == NULL) { closedir(self->dir); self->dir = NULL; done: return MP_OBJ_STOP_ITERATION; } mp_obj_tuple_t *t = MP_OBJ_TO_PTR(mp_obj_new_tuple(3, NULL)); t->items[0] = mp_obj_new_str(dirent->d_name, strlen(dirent->d_name), false); #ifdef _DIRENT_HAVE_D_TYPE t->items[1] = MP_OBJ_NEW_SMALL_INT(dirent->d_type); #else // DT_UNKNOWN should have 0 value on any reasonable system t->items[1] = MP_OBJ_NEW_SMALL_INT(0); #endif #ifdef _DIRENT_HAVE_D_INO t->items[2] = MP_OBJ_NEW_SMALL_INT(dirent->d_ino); #else t->items[2] = MP_OBJ_NEW_SMALL_INT(0); #endif return MP_OBJ_FROM_PTR(t); }
STATIC mp_obj_t neopixel_subscr(mp_obj_t self_in, mp_obj_t index_in, mp_obj_t value) { neopixel_obj_t *self = (neopixel_obj_t*)self_in; mp_uint_t index = mp_get_index(self->base.type, self->strip.num_leds, index_in, false); if (value == MP_OBJ_NULL) { // delete item return MP_OBJ_NULL; // op not supported } else if (value == MP_OBJ_SENTINEL) { // load mp_obj_t rgb[3] = { MP_OBJ_NEW_SMALL_INT(self->strip.leds[index].simple.r), MP_OBJ_NEW_SMALL_INT(self->strip.leds[index].simple.g), MP_OBJ_NEW_SMALL_INT(self->strip.leds[index].simple.b), }; return mp_obj_new_tuple(3, rgb); } else { // store mp_obj_t *rgb; mp_obj_get_array_fixed_n(value, 3, &rgb); mp_int_t r = mp_obj_get_int(rgb[0]); mp_int_t g = mp_obj_get_int(rgb[1]); mp_int_t b = mp_obj_get_int(rgb[2]); if (r < 0 || r > 255 || g < 0 || g > 255 || b < 0 || b > 255) { nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, "invalid colour")); } neopixel_set_color(&self->strip, index, r, g, b); return mp_const_none; } }
// function usocket.getaddrinfo(host, port) STATIC mp_obj_t mod_usocket_getaddrinfo(mp_obj_t host_in, mp_obj_t port_in) { size_t hlen; const char *host = mp_obj_str_get_data(host_in, &hlen); mp_int_t port = mp_obj_get_int(port_in); // find a NIC that can do a name lookup for (mp_uint_t i = 0; i < MP_STATE_PORT(mod_network_nic_list).len; i++) { mp_obj_t nic = MP_STATE_PORT(mod_network_nic_list).items[i]; mod_network_nic_type_t *nic_type = (mod_network_nic_type_t*)mp_obj_get_type(nic); if (nic_type->gethostbyname != NULL) { uint8_t out_ip[MOD_NETWORK_IPADDR_BUF_SIZE]; int ret = nic_type->gethostbyname(nic, host, hlen, out_ip); if (ret != 0) { // TODO CPython raises: socket.gaierror: [Errno -2] Name or service not known mp_raise_OSError(ret); } mp_obj_tuple_t *tuple = mp_obj_new_tuple(5, NULL); tuple->items[0] = MP_OBJ_NEW_SMALL_INT(MOD_NETWORK_AF_INET); tuple->items[1] = MP_OBJ_NEW_SMALL_INT(MOD_NETWORK_SOCK_STREAM); tuple->items[2] = MP_OBJ_NEW_SMALL_INT(0); tuple->items[3] = MP_OBJ_NEW_QSTR(MP_QSTR_); tuple->items[4] = netutils_format_inet_addr(out_ip, port, NETUTILS_BIG); return mp_obj_new_list(1, (mp_obj_t*)&tuple); } } nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, "no available NIC")); }
// method socket.accept() STATIC mp_obj_t socket_accept(mp_obj_t self_in) { mod_network_socket_obj_t *self = self_in; // create new socket object mod_network_socket_obj_t *socket2 = m_new_obj_with_finaliser(mod_network_socket_obj_t); // the new socket inherits all properties from its parent memcpy (socket2, self, sizeof(mod_network_socket_obj_t)); // accept the incoming connection uint8_t ip[MOD_NETWORK_IPV4ADDR_BUF_SIZE]; mp_uint_t port; int _errno; if (wlan_socket_accept(self, socket2, ip, &port, &_errno) != 0) { nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(-_errno))); } // add the socket to the list modusocket_socket_add(socket2->sock_base.sd, true); // make the return value mp_obj_tuple_t *client = mp_obj_new_tuple(2, NULL); client->items[0] = socket2; client->items[1] = netutils_format_inet_addr(ip, port, NETUTILS_LITTLE); return client; }
// method socket.recvfrom(bufsize) STATIC mp_obj_t socket_recvfrom(mp_obj_t self_in, mp_obj_t len_in) { mod_network_socket_obj_t *self = self_in; vstr_t vstr; vstr_init_len(&vstr, mp_obj_get_int(len_in)); byte ip[4]; mp_uint_t port; int _errno; mp_int_t ret = wlan_socket_recvfrom(self, (byte*)vstr.buf, vstr.len, ip, &port, &_errno); if (ret < 0) { if (_errno == EAGAIN && self->sock_base.has_timeout) { nlr_raise(mp_obj_new_exception_msg(&mp_type_TimeoutError, "timed out")); } nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(-_errno))); } mp_obj_t tuple[2]; if (ret == 0) { tuple[0] = mp_const_empty_bytes; } else { vstr.len = ret; vstr.buf[vstr.len] = '\0'; tuple[0] = mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr); } tuple[1] = netutils_format_inet_addr(ip, port, NETUTILS_LITTLE); return mp_obj_new_tuple(2, tuple); }
static mp_obj_t py_image_draw_keypoints(mp_obj_t image_obj, mp_obj_t kpts_obj) { image_t *image = NULL; py_kp_obj_t *kpts=NULL; /* get pointer */ image = py_image_cobj(image_obj); kpts = (py_kp_obj_t*)kpts_obj; /* sanity checks */ PY_ASSERT_TRUE_MSG(image->bpp == 1, "This function is only supported on GRAYSCALE images"); PY_ASSERT_TYPE(kpts_obj, &py_kp_type); color_t cl = {.r=0xFF, .g=0xFF, .b=0xFF}; for (int i=0; i<kpts->size; i++) { kp_t *kp = &kpts->kpts[i]; float co = arm_cos_f32(kp->angle); float si = arm_sin_f32(kp->angle); imlib_draw_line(image, kp->x, kp->y, kp->x+(co*10), kp->y+(si*10)); imlib_draw_circle(image, kp->x, kp->y, 4, &cl); } return mp_const_none; } static mp_obj_t py_image_find_blobs(mp_obj_t image_obj) { /* C stuff */ array_t *blobs; struct image *image; mp_obj_t blob_obj[6]; /* MP List */ mp_obj_t objects_list = mp_const_none; /* get image pointer */ image = py_image_cobj(image_obj); /* run color dector */ blobs = imlib_count_blobs(image); /* Create empty Python list */ objects_list = mp_obj_new_list(0, NULL); if (array_length(blobs)) { for (int j=0; j<array_length(blobs); j++) { blob_t *r = array_at(blobs, j); blob_obj[0] = mp_obj_new_int(r->x); blob_obj[1] = mp_obj_new_int(r->y); blob_obj[2] = mp_obj_new_int(r->w); blob_obj[3] = mp_obj_new_int(r->h); blob_obj[4] = mp_obj_new_int(r->c); blob_obj[5] = mp_obj_new_int(r->id); mp_obj_list_append(objects_list, mp_obj_new_tuple(6, blob_obj)); } } array_free(blobs); return objects_list; }
// method socket.recvfrom(bufsize) STATIC mp_obj_t socket_recvfrom(mp_obj_t self_in, mp_obj_t len_in) { mod_network_socket_obj_t *self = self_in; if (self->nic == MP_OBJ_NULL) { // not connected nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(ENOTCONN))); } vstr_t vstr; vstr_init_len(&vstr, mp_obj_get_int(len_in)); byte ip[4]; mp_uint_t port; int _errno; mp_int_t ret = self->nic_type->recvfrom(self, (byte*)vstr.buf, vstr.len, ip, &port, &_errno); if (ret == -1) { nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(_errno))); } mp_obj_t tuple[2]; if (ret == 0) { tuple[0] = mp_const_empty_bytes; } else { vstr.len = ret; tuple[0] = mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr); } tuple[1] = mod_network_format_inet_addr(ip, port); return mp_obj_new_tuple(2, tuple); }
// Takes an array with a raw IP address, and a port, and returns a net-address // tuple such as ('192.168.0.1', 8080). mp_obj_t mod_network_format_inet_addr(uint8_t *ip, mp_uint_t port) { mp_obj_t tuple[2] = { tuple[0] = mod_network_format_ipv4_addr(ip), tuple[1] = mp_obj_new_int(port), }; return mp_obj_new_tuple(2, tuple); }
STATIC mp_obj_t socket_accept(const mp_obj_t arg0) { socket_obj_t *self = MP_OBJ_TO_PTR(arg0); struct sockaddr addr; socklen_t addr_len = sizeof(addr); int new_fd = -1; for (int i=0; i<=self->retries; i++) { MP_THREAD_GIL_EXIT(); new_fd = lwip_accept_r(self->fd, &addr, &addr_len); MP_THREAD_GIL_ENTER(); if (new_fd >= 0) break; if (errno != EAGAIN) exception_from_errno(errno); check_for_exceptions(); } if (new_fd < 0) mp_raise_OSError(MP_ETIMEDOUT); // create new socket object socket_obj_t *sock = m_new_obj_with_finaliser(socket_obj_t); sock->base.type = self->base.type; sock->fd = new_fd; sock->domain = self->domain; sock->type = self->type; sock->proto = self->proto; _socket_settimeout(sock, UINT64_MAX); // make the return value uint8_t *ip = (uint8_t*)&((struct sockaddr_in*)&addr)->sin_addr; mp_uint_t port = lwip_ntohs(((struct sockaddr_in*)&addr)->sin_port); mp_obj_tuple_t *client = mp_obj_new_tuple(2, NULL); client->items[0] = sock; client->items[1] = netutils_format_inet_addr(ip, port, NETUTILS_BIG); return client; }
// method socket.accept() STATIC mp_obj_t socket_accept(mp_obj_t self_in) { mod_network_socket_obj_t *self = self_in; // create new socket object // starts with empty NIC so that finaliser doesn't run close() method if accept() fails mod_network_socket_obj_t *socket2 = m_new_obj_with_finaliser(mod_network_socket_obj_t); socket2->base.type = (mp_obj_t)&socket_type; socket2->nic = MP_OBJ_NULL; socket2->nic_type = NULL; // accept incoming connection uint8_t ip[MOD_NETWORK_IPADDR_BUF_SIZE]; mp_uint_t port; int _errno; if (self->nic_type->accept(self, socket2, ip, &port, &_errno) != 0) { nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(_errno))); } // new socket has valid state, so set the NIC to the same as parent socket2->nic = self->nic; socket2->nic_type = self->nic_type; // make the return value mp_obj_tuple_t *client = mp_obj_new_tuple(2, NULL); client->items[0] = socket2; client->items[1] = mod_network_format_inet_addr(ip, port); return client; }
/** * Perform the equivalent of a stat() system call on the given path. * * def stat(path) */ static mp_obj_t os_stat(mp_obj_t path_in) { const char *path_p; struct fs_stat_t stat; mp_obj_tuple_t *stat_p; int res; path_p = mp_obj_str_get_str(path_in); res = fs_stat(path_p, &stat); if (res != 0) { nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError, "Failed to stat '%s'", path_p)); } stat_p = mp_obj_new_tuple(10, NULL); stat_p->items[0] = MP_OBJ_NEW_SMALL_INT(0); /* st_mode */ stat_p->items[1] = MP_OBJ_NEW_SMALL_INT(0); /* st_ino */ stat_p->items[2] = MP_OBJ_NEW_SMALL_INT(0); /* st_dev */ stat_p->items[3] = MP_OBJ_NEW_SMALL_INT(0); /* st_nlink */ stat_p->items[4] = MP_OBJ_NEW_SMALL_INT(0); /* st_uid */ stat_p->items[5] = MP_OBJ_NEW_SMALL_INT(0); /* st_gid */ stat_p->items[6] = MP_OBJ_NEW_SMALL_INT(stat.size); /* st_size */ stat_p->items[7] = MP_OBJ_NEW_SMALL_INT(0); /* st_atime */ stat_p->items[8] = MP_OBJ_NEW_SMALL_INT(0); /* st_mtime */ stat_p->items[9] = MP_OBJ_NEW_SMALL_INT(0); /* st_ctime */ return (stat_p); }
STATIC mp_obj_t btree_iternext(mp_obj_t self_in) { mp_obj_btree_t *self = MP_OBJ_TO_PTR(self_in); DBT key, val; int res; // Different ports may have different type sizes mp_uint_t v; bool desc = self->flags & FLAG_DESC; if (self->start_key != MP_OBJ_NULL) { int flags = R_FIRST; if (self->start_key != mp_const_none) { key.data = (void*)mp_obj_str_get_data(self->start_key, &v); key.size = v; flags = R_CURSOR; } else if (desc) { flags = R_LAST; } res = __bt_seq(self->db, &key, &val, flags); self->start_key = MP_OBJ_NULL; } else { res = __bt_seq(self->db, &key, &val, desc ? R_PREV : R_NEXT); } if (res == RET_SPECIAL) { return MP_OBJ_STOP_ITERATION; } CHECK_ERROR(res); if (self->end_key != mp_const_none) { DBT end_key; end_key.data = (void*)mp_obj_str_get_data(self->end_key, &v); end_key.size = v; BTREE *t = self->db->internal; int cmp = t->bt_cmp(&key, &end_key); if (desc) { cmp = -cmp; } if (self->flags & FLAG_END_KEY_INCL) { cmp--; } if (cmp >= 0) { self->end_key = MP_OBJ_NULL; return MP_OBJ_STOP_ITERATION; } } switch (self->flags & FLAG_ITER_TYPE_MASK) { case FLAG_ITER_KEYS: return mp_obj_new_bytes(key.data, key.size); case FLAG_ITER_VALUES: return mp_obj_new_bytes(val.data, val.size); default: { mp_obj_t pair_o = mp_obj_new_tuple(2, NULL); mp_obj_tuple_t *pair = MP_OBJ_TO_PTR(pair_o); pair->items[0] = mp_obj_new_bytes(key.data, key.size); pair->items[1] = mp_obj_new_bytes(val.data, val.size); return pair_o; } } }
mp_obj_t mp_math_modf(mp_obj_t x_obj) { mp_float_t int_part = 0.0; mp_float_t fractional_part = MICROPY_FLOAT_C_FUN(modf)(mp_obj_get_float(x_obj), &int_part); mp_obj_t tuple[2]; tuple[0] = mp_obj_new_float(fractional_part); tuple[1] = mp_obj_new_float(int_part); return mp_obj_new_tuple(2, tuple); }
// Functions that return a tuple mp_obj_t mp_math_frexp(mp_obj_t x_obj) { int int_exponent = 0; mp_float_t significand = MICROPY_FLOAT_C_FUN(frexp)(mp_obj_get_float(x_obj), &int_exponent); mp_obj_t tuple[2]; tuple[0] = mp_obj_new_float(significand); tuple[1] = mp_obj_new_int(int_exponent); return mp_obj_new_tuple(2, tuple); }
/// \function freq() /// Return a tuple of clock frequencies: (SYSCLK, HCLK, PCLK1, PCLK2). // TODO should also be able to set frequency via this function STATIC mp_obj_t pyb_freq(void) { mp_obj_t tuple[3] = { mp_obj_new_int(F_CPU), mp_obj_new_int(F_BUS), mp_obj_new_int(F_MEM), }; return mp_obj_new_tuple(3, tuple); }
static mp_obj_t py_select(uint n_args, const mp_obj_t *args) { int nfds=0; //highest-numbered fd plus 1 timeval tv={0}; fd_set rfds, wfds, xfds; mp_obj_t *rlist, *wlist, *xlist; uint rlist_len, wlist_len, xlist_len; /* read args */ mp_obj_get_array(args[0], &rlist_len, &rlist); mp_obj_get_array(args[1], &wlist_len, &wlist); mp_obj_get_array(args[2], &xlist_len, &xlist); if (n_args == 4) { float timeout = mp_obj_get_float(args[3]); tv.tv_sec = (int)timeout; tv.tv_usec = (timeout-(int)timeout)*1000*1000; } // add fds to their respective sets set_fds(&nfds, rlist, rlist_len, &rfds); set_fds(&nfds, wlist, wlist_len, &wfds); set_fds(&nfds, xlist, xlist_len, &xfds); // call select nfds = select(nfds+1, &rfds, &wfds, &xfds, &tv); // if any of the read sockets is closed, we add it to the read fd set, // a subsequent call to recv() returns 0. This behavior is consistent with BSD. for (int i=0; i<rlist_len; i++) { socket_t *s = rlist[i]; if (wlan_get_fd_state(s->fd)) { FD_SET(s->fd, &rfds); nfds = max(nfds, s->fd); } } // return value; a tuple of 3 lists mp_obj_t fds[3] = { mp_obj_new_list(0, NULL), mp_obj_new_list(0, NULL), mp_obj_new_list(0, NULL) }; // On success, select() returns the number of file descriptors contained // in the three returned descriptor sets which may be zero if the timeout // expires before anything interesting happens, -1 is returned on error. if (nfds == -1) { // select failed nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, "select failed")); } else if (nfds) { // an fd is ready get_fds(rlist, rlist_len, fds[0], &rfds); get_fds(wlist, wlist_len, fds[1], &wfds); get_fds(xlist, xlist_len, fds[2], &xfds); } // select timedout return mp_obj_new_tuple(3, fds); }
/// \function freq() /// Return a tuple of clock frequencies: (SYSCLK, HCLK, PCLK1, PCLK2). // TODO should also be able to set frequency via this function STATIC mp_obj_t pyb_freq(void) { mp_obj_t tuple[4] = { mp_obj_new_int(HAL_RCC_GetSysClockFreq()), mp_obj_new_int(HAL_RCC_GetHCLKFreq()), mp_obj_new_int(HAL_RCC_GetPCLK1Freq()), mp_obj_new_int(HAL_RCC_GetPCLK2Freq()), }; return mp_obj_new_tuple(4, tuple); }
mp_obj_t mp_cmath_polar(mp_obj_t z_obj) { mp_float_t real, imag; mp_obj_get_complex(z_obj, &real, &imag); mp_obj_t tuple[2] = { mp_obj_new_float(MICROPY_FLOAT_C_FUN(sqrt)(real*real + imag*imag)), mp_obj_new_float(MICROPY_FLOAT_C_FUN(atan2)(imag, real)), }; return mp_obj_new_tuple(2, tuple); }
static mp_obj_t py_image_find_features(uint n_args, const mp_obj_t *args, mp_map_t *kw_args) { struct image *image = NULL; struct cascade *cascade = NULL; array_t *objects_array=NULL; mp_obj_t objects_list = mp_const_none; /* sanity checks */ PY_ASSERT_TRUE_MSG(sensor.pixformat == PIXFORMAT_GRAYSCALE, "This function is only supported on GRAYSCALE images"); PY_ASSERT_TRUE_MSG(sensor.framesize <= OMV_MAX_INT_FRAME, "This function is only supported on "OMV_MAX_INT_FRAME_STR" and smaller frames"); /* read arguments */ image = py_image_cobj(args[0]); cascade = py_cascade_cobj(args[1]); /* set some defaults */ cascade->threshold = 0.65f; cascade->scale_factor = 1.65f; /* read kw args */ mp_map_elem_t *kw_thresh = mp_map_lookup(kw_args, MP_OBJ_NEW_QSTR(qstr_from_str("threshold")), MP_MAP_LOOKUP); if (kw_thresh != NULL) { cascade->threshold = mp_obj_get_float(kw_thresh->value); } mp_map_elem_t *kw_scalef = mp_map_lookup(kw_args, MP_OBJ_NEW_QSTR(qstr_from_str("scale")), MP_MAP_LOOKUP); if (kw_scalef != NULL) { cascade->scale_factor = mp_obj_get_float(kw_scalef->value); } /* Detect objects */ objects_array = imlib_detect_objects(image, cascade); /* Create empty Python list */ objects_list = mp_obj_new_list(0, NULL); /* Add detected objects to the list */ for (int i=0; i<array_length(objects_array); i++) { struct rectangle *r = array_at(objects_array, i); mp_obj_t rec_obj[4] = { mp_obj_new_int(r->x), mp_obj_new_int(r->y), mp_obj_new_int(r->w), mp_obj_new_int(r->h), }; mp_obj_list_append(objects_list, mp_obj_new_tuple(4, rec_obj)); } /* Free the objects array */ array_free(objects_array); return objects_list; }
/// \method alarm_datetime([datetimetuple,alarmMask]) STATIC mp_obj_t rtc_alarm_datetime(mp_uint_t n_args, const mp_obj_t *args) { //pyb_rtc_obj_t *self = args[0]; if (n_args == 1) { // get uint32_t yr; uint32_t mon; uint32_t day; uint32_t wd; uint32_t hr; uint32_t min; uint32_t sec; mp_obj_t tuple[7]; mp_hal_getAlarmTimeRTC(&hr, &min, &sec, &day, &mon, &yr, &wd); tuple[0] = MP_OBJ_NEW_SMALL_INT(yr); tuple[1] = MP_OBJ_NEW_SMALL_INT(mon); tuple[2] = MP_OBJ_NEW_SMALL_INT(day); tuple[3] = MP_OBJ_NEW_SMALL_INT(wd); tuple[4] = MP_OBJ_NEW_SMALL_INT(hr); tuple[5] = MP_OBJ_NEW_SMALL_INT(min); tuple[6] = MP_OBJ_NEW_SMALL_INT(sec); return mp_obj_new_tuple(7,tuple); } else if(n_args == 3) { // set //(year, month, day, weekday, hours, minutes, seconds) mp_buffer_info_t bufinfo; mp_obj_t *items; mp_obj_get_array(args[1], &bufinfo.len, &items); uint32_t alarmMask = mp_obj_get_int(args[2]); if(bufinfo.len==7) { uint32_t yr = mp_obj_get_int(items[0]); uint32_t mon = mp_obj_get_int(items[1]); uint32_t day = mp_obj_get_int(items[2]); uint32_t wd = mp_obj_get_int(items[3]); uint32_t hr = mp_obj_get_int(items[4]); uint32_t min = mp_obj_get_int(items[5]); uint32_t sec = mp_obj_get_int(items[6]); mp_hal_setAlarmTimeRTC(hr,min,sec,day,mon,yr,wd,alarmMask); } else{ nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, "7 arguments are required in tuple")); } return mp_const_none; } else { nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, "2 arguments are required")); } }
mp_obj_t mp_obj_new_attrtuple(const qstr *fields, mp_uint_t n, const mp_obj_t *items) { mp_obj_tuple_t *o = mp_obj_new_tuple(n + 1, NULL); o->base.type = &mp_type_attrtuple; for (mp_uint_t i = 0; i < n; i++) { o->items[i] = items[i]; } o->items[n] = (void*)fields; return o; }
STATIC mp_obj_t namedtuple_make_new(const mp_obj_type_t *type_in, size_t n_args, size_t n_kw, const mp_obj_t *args) { const mp_obj_namedtuple_type_t *type = (const mp_obj_namedtuple_type_t*)type_in; size_t num_fields = type->n_fields; if (n_args + n_kw != num_fields) { if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) { mp_arg_error_terse_mismatch(); } else if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_NORMAL) { nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "function takes %d positional arguments but %d were given", num_fields, n_args + n_kw)); } else if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_DETAILED) { nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "%q() takes %d positional arguments but %d were given", type->base.name, num_fields, n_args + n_kw)); } } mp_obj_t *arg_objects; if (n_args == num_fields) { arg_objects = (mp_obj_t*)args; } else { size_t alloc_size = sizeof(mp_obj_t) * num_fields; arg_objects = alloca(alloc_size); memset(arg_objects, 0, alloc_size); for (mp_uint_t i = 0; i < n_args; i++) { arg_objects[i] = args[i]; } for (mp_uint_t i = n_args; i < n_args + 2 * n_kw; i += 2) { qstr kw = mp_obj_str_get_qstr(args[i]); int id = namedtuple_find_field(type, kw); if (id == -1) { if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) { mp_arg_error_terse_mismatch(); } else { nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "unexpected keyword argument '%q'", kw)); } } if (arg_objects[id] != MP_OBJ_NULL) { if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) { mp_arg_error_terse_mismatch(); } else { nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "function got multiple values for argument '%q'", kw)); } } arg_objects[id] = args[i + 1]; } } mp_obj_tuple_t *tuple = MP_OBJ_TO_PTR(mp_obj_new_tuple(num_fields, arg_objects)); tuple->base.type = type_in; return MP_OBJ_FROM_PTR(tuple); }
static mp_obj_t mod_wlan_patch_version() { uint8_t pver[2]; mp_obj_tuple_t *t_pver = mp_obj_new_tuple(2, NULL); nvmem_read_sp_version(pver); t_pver->items[0] = mp_obj_new_int(pver[0]); t_pver->items[1] = mp_obj_new_int(pver[1]); return t_pver; }
mp_obj_t py_cpufreq_get_current_frequencies() { mp_obj_t tuple[4] = { mp_obj_new_int(cpufreq_get_cpuclk() / (1000000)), mp_obj_new_int(HAL_RCC_GetHCLKFreq() / (1000000)), mp_obj_new_int(HAL_RCC_GetPCLK1Freq() / (1000000)), mp_obj_new_int(HAL_RCC_GetPCLK2Freq() / (1000000)), }; return mp_obj_new_tuple(4, tuple); }
STATIC mp_obj_t pkt_get_info(void) { struct k_mem_slab *rx, *tx; struct net_buf_pool *rx_data, *tx_data; net_pkt_get_info(&rx, &tx, &rx_data, &tx_data); mp_obj_tuple_t *t = MP_OBJ_TO_PTR(mp_obj_new_tuple(4, NULL)); t->items[0] = MP_OBJ_NEW_SMALL_INT(k_mem_slab_num_free_get(rx)); t->items[1] = MP_OBJ_NEW_SMALL_INT(k_mem_slab_num_free_get(tx)); t->items[2] = MP_OBJ_NEW_SMALL_INT(rx_data->avail_count); t->items[3] = MP_OBJ_NEW_SMALL_INT(tx_data->avail_count); return MP_OBJ_FROM_PTR(t); }
STATIC mp_obj_t pin_alt_list(mp_obj_t self_in) { pin_obj_t *self = self_in; mp_obj_t af[2]; mp_obj_t afs = mp_obj_new_list(0, NULL); for (int i = 0; i < self->num_afs; i++) { af[0] = MP_OBJ_NEW_QSTR(self->af_list[i].name); af[1] = mp_obj_new_int(self->af_list[i].idx); mp_obj_list_append(afs, mp_obj_new_tuple(MP_ARRAY_SIZE(af), af)); } return afs; }
STATIC mp_obj_t mp_builtin_divmod(mp_obj_t o1_in, mp_obj_t o2_in) { if (MP_OBJ_IS_SMALL_INT(o1_in) && MP_OBJ_IS_SMALL_INT(o2_in)) { mp_small_int_t i1 = MP_OBJ_SMALL_INT_VALUE(o1_in); mp_small_int_t i2 = MP_OBJ_SMALL_INT_VALUE(o2_in); mp_obj_t args[2]; args[0] = MP_OBJ_NEW_SMALL_INT(i1 / i2); args[1] = MP_OBJ_NEW_SMALL_INT(i1 % i2); return mp_obj_new_tuple(2, args); } else { nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "unsupported operand type(s) for divmod(): '%s' and '%s'", mp_obj_get_type_str(o1_in), mp_obj_get_type_str(o2_in))); } }