STATIC mp_obj_t wlan_scan(mp_obj_t self_in) {
STATIC const qstr wlan_scan_info_fields[] = {
MP_QSTR_ssid, MP_QSTR_bssid, MP_QSTR_sec, MP_QSTR_channel, MP_QSTR_rssi
};
// check for correct wlan mode
if (wlan_obj.mode == ROLE_AP) {
mp_raise_OSError(MP_EPERM);
}
Sl_WlanNetworkEntry_t wlanEntry;
mp_obj_t nets = mp_obj_new_list(0, NULL);
uint8_t _index = 0;
// trigger a new network scan
uint32_t scanSeconds = MODWLAN_SCAN_PERIOD_S;
ASSERT_ON_ERROR(sl_WlanPolicySet(SL_POLICY_SCAN , MODWLAN_SL_SCAN_ENABLE, (_u8 *)&scanSeconds, sizeof(scanSeconds)));
// wait for the scan to complete
mp_hal_delay_ms(MODWLAN_WAIT_FOR_SCAN_MS);
do {
if (sl_WlanGetNetworkList(_index++, 1, &wlanEntry) <= 0) {
break;
}
// we must skip any duplicated results
if (!wlan_scan_result_is_unique(nets, wlanEntry.bssid)) {
continue;
}
mp_obj_t tuple[5];
tuple[0] = mp_obj_new_str((const char *)wlanEntry.ssid, wlanEntry.ssid_len, false);
tuple[1] = mp_obj_new_bytes((const byte *)wlanEntry.bssid, SL_BSSID_LENGTH);
// 'normalize' the security type
if (wlanEntry.sec_type > 2) {
wlanEntry.sec_type = 2;
}
tuple[2] = mp_obj_new_int(wlanEntry.sec_type);
tuple[3] = mp_const_none;
tuple[4] = mp_obj_new_int(wlanEntry.rssi);
// add the network to the list
mp_obj_list_append(nets, mp_obj_new_attrtuple(wlan_scan_info_fields, 5, tuple));
} while (_index < MODWLAN_SL_MAX_NETWORKS);
return nets;
}
/// \method get_config()
/// Returns a named tupple with the current configuration of the gpio pin
STATIC mp_obj_t pin_get_config(mp_obj_t self_in) {
STATIC const qstr pin_config_fields[] = {
MP_QSTR_name, MP_QSTR_af, MP_QSTR_mode,
MP_QSTR_type, MP_QSTR_strength
};
pin_obj_t *self = self_in;
mp_obj_t pin_config[5];
pin_config[0] = MP_OBJ_NEW_QSTR(self->name);
pin_config[1] = mp_obj_new_int(self->af);
pin_config[2] = mp_obj_new_int(self->mode);
pin_config[3] = mp_obj_new_int(self->type);
pin_config[4] = mp_obj_new_int(self->strength);
return mp_obj_new_attrtuple(pin_config_fields, 5, pin_config);
}
/**
* def read_cid(self)
*/
static mp_obj_t class_sd_read_cid(mp_obj_t self_in)
{
struct class_sd_t *self_p;
struct sd_cid_t cid;
mp_obj_t tuple[7];
self_p = MP_OBJ_TO_PTR(self_in);
if (sd_read_cid(&self_p->drv, &cid) != sizeof(cid)) {
nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError,
"sd_read_cid() failed"));
}
tuple[0] = MP_OBJ_NEW_SMALL_INT(cid.mid);
tuple[1] = mp_obj_new_bytes((const byte *)cid.oid, sizeof(cid.oid));
tuple[2] = mp_obj_new_bytes((const byte *)cid.pnm, sizeof(cid.pnm));
tuple[3] = MP_OBJ_NEW_SMALL_INT(cid.prv);
tuple[4] = mp_obj_new_int(cid.psn);
tuple[5] = mp_obj_new_int(cid.mdt);
tuple[6] = MP_OBJ_NEW_SMALL_INT(cid.crc);
return (mp_obj_new_attrtuple(&cid_fields[0], 7, tuple));
}
// function to run extra tests for things that can't be checked by scripts
STATIC mp_obj_t extra_coverage(void) {
// mp_printf (used by ports that don't have a native printf)
{
printf("# mp_printf\n");
mp_printf(&mp_plat_print, "%"); // nothing after percent
mp_printf(&mp_plat_print, "%d %+d % d\n", -123, 123, 123); // sign
mp_printf(&mp_plat_print, "%05d\n", -123); // negative number with zero padding
mp_printf(&mp_plat_print, "%ld\n", 123); // long
mp_printf(&mp_plat_print, "%X\n", 0x1abcdef); // capital hex
mp_printf(&mp_plat_print, "%.2s %.3s\n", "abc", "abc"); // fixed string precision
mp_printf(&mp_plat_print, "%.*s\n", -1, "abc"); // negative string precision
mp_printf(&mp_plat_print, "%b %b\n", 0, 1); // bools
mp_printf(&mp_plat_print, "%s\n", NULL); // null string
mp_printf(&mp_plat_print, "%t\n"); // non-format char
}
// vstr
{
printf("# vstr\n");
vstr_t *vstr = vstr_new_size(16);
vstr_hint_size(vstr, 32);
vstr_add_str(vstr, "ts");
vstr_ins_byte(vstr, 1, 'e');
vstr_ins_char(vstr, 3, 't');
vstr_ins_char(vstr, 10, 's');
printf("%.*s\n", (int)vstr->len, vstr->buf);
vstr_cut_head_bytes(vstr, 2);
printf("%.*s\n", (int)vstr->len, vstr->buf);
vstr_cut_tail_bytes(vstr, 10);
printf("%.*s\n", (int)vstr->len, vstr->buf);
vstr_printf(vstr, "t%cst", 'e');
printf("%.*s\n", (int)vstr->len, vstr->buf);
vstr_cut_out_bytes(vstr, 3, 10);
printf("%.*s\n", (int)vstr->len, vstr->buf);
VSTR_FIXED(fix, 4);
vstr_add_str(&fix, "large");
printf("%.*s\n", (int)fix.len, fix.buf);
}
// repl autocomplete
{
printf("# repl\n");
const char *str;
mp_uint_t len = mp_repl_autocomplete("__n", 3, &mp_plat_print, &str);
printf("%.*s\n", (int)len, str);
mp_store_global(MP_QSTR_sys, mp_import_name(MP_QSTR_sys, mp_const_none, MP_OBJ_NEW_SMALL_INT(0)));
mp_repl_autocomplete("sys.", 4, &mp_plat_print, &str);
len = mp_repl_autocomplete("sys.impl", 8, &mp_plat_print, &str);
printf("%.*s\n", (int)len, str);
}
// attrtuple
{
printf("# attrtuple\n");
static const qstr fields[] = {MP_QSTR_start, MP_QSTR_stop, MP_QSTR_step};
static const mp_obj_t items[] = {MP_OBJ_NEW_SMALL_INT(1), MP_OBJ_NEW_SMALL_INT(2), MP_OBJ_NEW_SMALL_INT(3)};
mp_obj_print_helper(&mp_plat_print, mp_obj_new_attrtuple(fields, 3, items), PRINT_REPR);
printf("\n");
}
return mp_const_none;
}
// function to run extra tests for things that can't be checked by scripts
STATIC mp_obj_t extra_coverage(void) {
// mp_printf (used by ports that don't have a native printf)
{
mp_printf(&mp_plat_print, "# mp_printf\n");
mp_printf(&mp_plat_print, "%d %+d % d\n", -123, 123, 123); // sign
mp_printf(&mp_plat_print, "%05d\n", -123); // negative number with zero padding
mp_printf(&mp_plat_print, "%ld\n", 123); // long
mp_printf(&mp_plat_print, "%X\n", 0x1abcdef); // capital hex
mp_printf(&mp_plat_print, "%.2s %.3s\n", "abc", "abc"); // fixed string precision
mp_printf(&mp_plat_print, "%.*s\n", -1, "abc"); // negative string precision
mp_printf(&mp_plat_print, "%b %b\n", 0, 1); // bools
mp_printf(&mp_plat_print, "%s\n", NULL); // null string
mp_printf(&mp_plat_print, "%d\n", 0x80000000); // should print signed
mp_printf(&mp_plat_print, "%u\n", 0x80000000); // should print unsigned
mp_printf(&mp_plat_print, "%x\n", 0x80000000); // should print unsigned
mp_printf(&mp_plat_print, "%X\n", 0x80000000); // should print unsigned
}
// vstr
{
mp_printf(&mp_plat_print, "# vstr\n");
vstr_t *vstr = vstr_new(16);
vstr_hint_size(vstr, 32);
vstr_add_str(vstr, "ts");
vstr_ins_byte(vstr, 1, 'e');
vstr_ins_char(vstr, 3, 't');
vstr_ins_char(vstr, 10, 's');
mp_printf(&mp_plat_print, "%.*s\n", (int)vstr->len, vstr->buf);
vstr_cut_head_bytes(vstr, 2);
mp_printf(&mp_plat_print, "%.*s\n", (int)vstr->len, vstr->buf);
vstr_cut_tail_bytes(vstr, 10);
mp_printf(&mp_plat_print, "%.*s\n", (int)vstr->len, vstr->buf);
vstr_printf(vstr, "t%cst", 'e');
mp_printf(&mp_plat_print, "%.*s\n", (int)vstr->len, vstr->buf);
vstr_cut_out_bytes(vstr, 3, 10);
mp_printf(&mp_plat_print, "%.*s\n", (int)vstr->len, vstr->buf);
VSTR_FIXED(fix, 4);
vstr_add_str(&fix, "large");
mp_printf(&mp_plat_print, "%.*s\n", (int)fix.len, fix.buf);
}
// repl autocomplete
{
mp_printf(&mp_plat_print, "# repl\n");
const char *str;
mp_uint_t len = mp_repl_autocomplete("__n", 3, &mp_plat_print, &str);
mp_printf(&mp_plat_print, "%.*s\n", (int)len, str);
mp_store_global(MP_QSTR_sys, mp_import_name(MP_QSTR_sys, mp_const_none, MP_OBJ_NEW_SMALL_INT(0)));
mp_repl_autocomplete("sys.", 4, &mp_plat_print, &str);
len = mp_repl_autocomplete("sys.impl", 8, &mp_plat_print, &str);
mp_printf(&mp_plat_print, "%.*s\n", (int)len, str);
}
// attrtuple
{
mp_printf(&mp_plat_print, "# attrtuple\n");
static const qstr fields[] = {MP_QSTR_start, MP_QSTR_stop, MP_QSTR_step};
static const mp_obj_t items[] = {MP_OBJ_NEW_SMALL_INT(1), MP_OBJ_NEW_SMALL_INT(2), MP_OBJ_NEW_SMALL_INT(3)};
mp_obj_print_helper(&mp_plat_print, mp_obj_new_attrtuple(fields, 3, items), PRINT_REPR);
mp_printf(&mp_plat_print, "\n");
}
// str
{
mp_printf(&mp_plat_print, "# str\n");
// intern string
mp_printf(&mp_plat_print, "%d\n", MP_OBJ_IS_QSTR(mp_obj_str_intern(mp_obj_new_str("intern me", 9, false))));
}
// mpz
{
mp_printf(&mp_plat_print, "# mpz\n");
mp_uint_t value;
mpz_t mpz;
mpz_init_zero(&mpz);
// mpz_as_uint_checked, with success
mpz_set_from_int(&mpz, 12345678);
mp_printf(&mp_plat_print, "%d\n", mpz_as_uint_checked(&mpz, &value));
mp_printf(&mp_plat_print, "%d\n", (int)value);
// mpz_as_uint_checked, with negative arg
mpz_set_from_int(&mpz, -1);
mp_printf(&mp_plat_print, "%d\n", mpz_as_uint_checked(&mpz, &value));
// mpz_as_uint_checked, with overflowing arg
mpz_set_from_int(&mpz, 1);
mpz_shl_inpl(&mpz, &mpz, 70);
mp_printf(&mp_plat_print, "%d\n", mpz_as_uint_checked(&mpz, &value));
}
// runtime utils
{
mp_printf(&mp_plat_print, "# runtime utils\n");
// call mp_call_function_1_protected
mp_call_function_1_protected(MP_OBJ_FROM_PTR(&mp_builtin_abs_obj), MP_OBJ_NEW_SMALL_INT(1));
// call mp_call_function_1_protected with invalid args
mp_call_function_1_protected(MP_OBJ_FROM_PTR(&mp_builtin_abs_obj), mp_obj_new_str("abc", 3, false));
// call mp_call_function_2_protected
mp_call_function_2_protected(MP_OBJ_FROM_PTR(&mp_builtin_divmod_obj), MP_OBJ_NEW_SMALL_INT(1), MP_OBJ_NEW_SMALL_INT(1));
// call mp_call_function_2_protected with invalid args
mp_call_function_2_protected(MP_OBJ_FROM_PTR(&mp_builtin_divmod_obj), mp_obj_new_str("abc", 3, false), mp_obj_new_str("abc", 3, false));
}
// warning
{
mp_emitter_warning(MP_PASS_CODE_SIZE, "test");
}
// format float
{
mp_printf(&mp_plat_print, "# format float\n");
// format with inadequate buffer size
char buf[5];
mp_format_float(1, buf, sizeof(buf), 'g', 0, '+');
mp_printf(&mp_plat_print, "%s\n", buf);
// format with just enough buffer so that precision must be
// set from 0 to 1 twice
char buf2[8];
mp_format_float(1, buf2, sizeof(buf2), 'g', 0, '+');
mp_printf(&mp_plat_print, "%s\n", buf2);
// format where precision is trimmed to avoid buffer overflow
mp_format_float(1, buf2, sizeof(buf2), 'e', 0, '+');
mp_printf(&mp_plat_print, "%s\n", buf2);
}
// return a tuple of data for testing on the Python side
mp_obj_t items[] = {(mp_obj_t)&str_no_hash_obj, (mp_obj_t)&bytes_no_hash_obj};
return mp_obj_new_tuple(MP_ARRAY_SIZE(items), items);
}
/**
* def read_cid(self)
*/
static mp_obj_t class_sd_read_csd(mp_obj_t self_in)
{
struct class_sd_t *self_p;
union sd_csd_t csd;
mp_obj_t tuple[29];
self_p = MP_OBJ_TO_PTR(self_in);
if (sd_read_csd(&self_p->drv, &csd) != sizeof(csd)) {
nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError,
"sd_read_csd() failed"));
}
switch (csd.v1.csd_structure) {
case SD_CSD_STRUCTURE_V1:
tuple[0] = MP_OBJ_NEW_SMALL_INT(csd.v1.csd_structure);
tuple[1] = MP_OBJ_NEW_SMALL_INT(csd.v1.taac);
tuple[2] = MP_OBJ_NEW_SMALL_INT(csd.v1.nsac);
tuple[3] = MP_OBJ_NEW_SMALL_INT(csd.v1.tran_speed);
tuple[4] = MP_OBJ_NEW_SMALL_INT(SD_CCC(&csd.v1));
tuple[5] = MP_OBJ_NEW_SMALL_INT(csd.v1.read_bl_len);
tuple[6] = MP_OBJ_NEW_SMALL_INT(csd.v1.read_bl_partial);
tuple[7] = MP_OBJ_NEW_SMALL_INT(csd.v1.write_blk_misalign);
tuple[8] = MP_OBJ_NEW_SMALL_INT(csd.v1.read_blk_misalign);
tuple[9] = MP_OBJ_NEW_SMALL_INT(csd.v1.dsr_imp);
tuple[10] = MP_OBJ_NEW_SMALL_INT(SD_C_SIZE(&csd.v1));
tuple[11] = MP_OBJ_NEW_SMALL_INT(csd.v1.vdd_r_curr_min);
tuple[12] = MP_OBJ_NEW_SMALL_INT(csd.v1.vdd_r_curr_max);
tuple[13] = MP_OBJ_NEW_SMALL_INT(csd.v1.vdd_w_curr_min);
tuple[14] = MP_OBJ_NEW_SMALL_INT(csd.v1.vdd_w_curr_max);
tuple[15] = MP_OBJ_NEW_SMALL_INT(SD_C_SIZE_MULT(&csd.v1));
tuple[16] = MP_OBJ_NEW_SMALL_INT(csd.v1.erase_blk_en);
tuple[17] = MP_OBJ_NEW_SMALL_INT(SD_SECTOR_SIZE(&csd.v1));
tuple[18] = MP_OBJ_NEW_SMALL_INT(csd.v1.wp_grp_size);
tuple[19] = MP_OBJ_NEW_SMALL_INT(csd.v1.wp_grp_enable);
tuple[20] = MP_OBJ_NEW_SMALL_INT(csd.v1.r2w_factor);
tuple[21] = MP_OBJ_NEW_SMALL_INT(SD_WRITE_BL_LEN(&csd.v1));
tuple[22] = MP_OBJ_NEW_SMALL_INT(csd.v1.write_bl_partial);
tuple[23] = MP_OBJ_NEW_SMALL_INT(csd.v1.file_format_grp);
tuple[24] = MP_OBJ_NEW_SMALL_INT(csd.v1.copy);
tuple[25] = MP_OBJ_NEW_SMALL_INT(csd.v1.perm_write_protect);
tuple[26] = MP_OBJ_NEW_SMALL_INT(csd.v1.tmp_write_protect);
tuple[27] = MP_OBJ_NEW_SMALL_INT(csd.v1.file_format);
tuple[28] = MP_OBJ_NEW_SMALL_INT(csd.v1.crc);
return (mp_obj_new_attrtuple(&csd_v1_fields[0], 29, tuple));
case SD_CSD_STRUCTURE_V2:
tuple[0] = MP_OBJ_NEW_SMALL_INT(csd.v2.csd_structure);
tuple[1] = MP_OBJ_NEW_SMALL_INT(csd.v2.taac);
tuple[2] = MP_OBJ_NEW_SMALL_INT(csd.v2.nsac);
tuple[3] = MP_OBJ_NEW_SMALL_INT(csd.v2.tran_speed);
tuple[4] = MP_OBJ_NEW_SMALL_INT(SD_CCC(&csd.v2));
tuple[5] = MP_OBJ_NEW_SMALL_INT(csd.v2.read_bl_len);
tuple[6] = MP_OBJ_NEW_SMALL_INT(csd.v2.dsr_imp);
tuple[7] = MP_OBJ_NEW_SMALL_INT(csd.v2.read_blk_misalign);
tuple[8] = MP_OBJ_NEW_SMALL_INT(csd.v2.write_blk_misalign);
tuple[9] = MP_OBJ_NEW_SMALL_INT(csd.v2.read_bl_partial);
tuple[10] = MP_OBJ_NEW_SMALL_INT(SD_C_SIZE(&csd.v2));
tuple[11] = MP_OBJ_NEW_SMALL_INT(SD_SECTOR_SIZE(&csd.v2));
tuple[12] = MP_OBJ_NEW_SMALL_INT(csd.v2.erase_blk_en);
tuple[13] = MP_OBJ_NEW_SMALL_INT(csd.v2.wp_grp_size);
tuple[14] = MP_OBJ_NEW_SMALL_INT(SD_WRITE_BL_LEN(&csd.v2));
tuple[15] = MP_OBJ_NEW_SMALL_INT(csd.v2.r2w_factor);
tuple[16] = MP_OBJ_NEW_SMALL_INT(csd.v2.wp_grp_enable);
tuple[17] = MP_OBJ_NEW_SMALL_INT(csd.v2.write_bl_partial);
tuple[18] = MP_OBJ_NEW_SMALL_INT(csd.v2.file_format);
tuple[19] = MP_OBJ_NEW_SMALL_INT(csd.v2.tmp_write_protect);
tuple[20] = MP_OBJ_NEW_SMALL_INT(csd.v2.perm_write_protect);
tuple[21] = MP_OBJ_NEW_SMALL_INT(csd.v2.copy);
tuple[22] = MP_OBJ_NEW_SMALL_INT(csd.v2.file_format_grp);
tuple[23] = MP_OBJ_NEW_SMALL_INT(csd.v2.crc);
return (mp_obj_new_attrtuple(&csd_v2_fields[0], 24, tuple));
default:
return (mp_const_none);
}
}
