/// \function millis() /// Returns the number of milliseconds since the board was last reset. STATIC mp_obj_t pyb_millis(void) { return mp_obj_new_int(HAL_GetTick()); }
/// \method info() /// Get information about the startup time and reset source. /// /// - The lower 0xffff are the number of milliseconds the RTC took to /// start up. /// - Bit 0x10000 is set if a power-on reset occurred. /// - Bit 0x20000 is set if an external reset occurred mp_obj_t pyb_rtc_info(mp_obj_t self_in) { return mp_obj_new_int(rtc_info); }
STATIC mp_obj_t read_axis(int axis) { uint8_t data[1]; HAL_I2C_Mem_Read(&I2CHandle1, MMA_ADDR, axis, I2C_MEMADD_SIZE_8BIT, data, 1, 200); return mp_obj_new_int(MMA_AXIS_SIGNED_VALUE(data[0])); }
STATIC mp_obj_t test_get(mp_obj_t self_in) { test_obj_t *self = self_in; return mp_obj_new_int(self->value); }
mp_obj_t microbit_compass_heading(mp_obj_t self_in) { microbit_compass_obj_t *self = (microbit_compass_obj_t*)self_in; return mp_obj_new_int(self->compass->heading()); }
STATIC mp_obj_t microbit_random(mp_obj_t max_in) { return mp_obj_new_int(uBit.random(mp_obj_get_int(max_in))); }
STATIC mp_obj_t machine_reset_cause (void) { return mp_obj_new_int(pyb_sleep_get_reset_cause()); }
/// \method read() /// Read the value on the analog pin and return it. The returned value /// will be between 0 and 4095. STATIC mp_obj_t adc_read(mp_obj_t self_in) { pyb_obj_adc_t *self = self_in; uint32_t data = adc_read_channel(&self->handle); return mp_obj_new_int(data); }
static mp_obj_t py_sensor_read_reg(mp_obj_t addr) { return mp_obj_new_int(SCCB_Read(mp_obj_get_int(addr))); }
STATIC mp_obj_t mod_eoslib_action_size(void) { return mp_obj_new_int(get_vm_api()->action_data_size()); }
STATIC mp_obj_t mod_citrus_gfx_get_screen_format(mp_obj_t which) { int screen = _mod_citrus_gfx_get_gfx_screen(which); int ret = gfxGetScreenFormat(screen); return mp_obj_new_int(ret); }
STATIC mp_obj_t mod_eoslib_now(void) { return mp_obj_new_int(get_vm_api()->now()); }
STATIC mp_obj_t py_cpu_freq(void ) { return mp_obj_new_int(SystemCoreClock); }
STATIC mp_obj_t py_randint(mp_obj_t min, mp_obj_t max) { return mp_obj_new_int(rng_randint(mp_obj_get_int(min), mp_obj_get_int(max))); }
STATIC mp_obj_t time_time(void) { return mp_obj_new_int(pyb_rtc_get_seconds()); }
// Disable interrupt requests STATIC mp_obj_t machine_disable_irq(void) { uint32_t state = __get_PRIMASK(); __disable_irq(); return mp_obj_new_int(state); }
/// \function localtime([secs]) /// Convert a time expressed in seconds since Jan 1, 2000 into an 8-tuple which /// contains: (year, month, mday, hour, minute, second, weekday, yearday) /// If secs is not provided or None, then the current time from the RTC is used. /// year includes the century (for example 2015) /// month is 1-12 /// mday is 1-31 /// hour is 0-23 /// minute is 0-59 /// second is 0-59 /// weekday is 0-6 for Mon-Sun. /// yearday is 1-366 STATIC mp_obj_t time_localtime(mp_uint_t n_args, const mp_obj_t *args) { if (n_args == 0 || args[0] == mp_const_none) { timeutils_struct_time_t tm; // get the seconds from the RTC timeutils_seconds_since_2000_to_struct_time(pyb_rtc_get_seconds(), &tm); mp_obj_t tuple[8] = { mp_obj_new_int(tm.tm_year), mp_obj_new_int(tm.tm_mon), mp_obj_new_int(tm.tm_mday), mp_obj_new_int(tm.tm_hour), mp_obj_new_int(tm.tm_min), mp_obj_new_int(tm.tm_sec), mp_obj_new_int(tm.tm_wday), mp_obj_new_int(tm.tm_yday) }; return mp_obj_new_tuple(8, tuple); } else { mp_int_t seconds = mp_obj_get_int(args[0]); timeutils_struct_time_t tm; timeutils_seconds_since_2000_to_struct_time(seconds, &tm); mp_obj_t tuple[8] = { tuple[0] = mp_obj_new_int(tm.tm_year), tuple[1] = mp_obj_new_int(tm.tm_mon), tuple[2] = mp_obj_new_int(tm.tm_mday), tuple[3] = mp_obj_new_int(tm.tm_hour), tuple[4] = mp_obj_new_int(tm.tm_min), tuple[5] = mp_obj_new_int(tm.tm_sec), tuple[6] = mp_obj_new_int(tm.tm_wday), tuple[7] = mp_obj_new_int(tm.tm_yday), }; return mp_obj_new_tuple(8, tuple); } }
/// \function time() /// Returns the number of seconds, as an integer, since 1/1/2000. STATIC mp_obj_t time_time(void) { // get date and time return mp_obj_new_int(pyb_rtc_get_us_since_2000() / 1000 / 1000); }
STATIC mp_obj_t machine_freq(void) { mp_obj_t tuple[1] = { mp_obj_new_int(HAL_FCPU_HZ), }; return mp_obj_new_tuple(1, tuple); }
void TASK_Micropython (void *pvParameters) { // initialize the garbage collector with the top of our stack uint32_t sp = gc_helper_get_sp(); gc_collect_init (sp); bool safeboot = false; FRESULT res; mptask_pre_init(); soft_reset: // GC init gc_init(&_boot, &_eheap); // MicroPython init mp_init(); mp_obj_list_init(mp_sys_path, 0); mp_obj_list_init(mp_sys_argv, 0); mp_obj_list_append(mp_sys_path, MP_OBJ_NEW_QSTR(MP_QSTR_)); // current dir (or base dir of the script) // execute all basic initializations mpexception_init0(); mpcallback_init0(); pybsleep_init0(); mperror_init0(); uart_init0(); pin_init0(); readline_init0(); mod_network_init0(); #if MICROPY_HW_ENABLE_RNG rng_init0(); #endif // we are alive, so let the world know it mperror_enable_heartbeat(); #ifdef LAUNCHXL // configure the stdio uart pins with the correct alternate functions // param 3 ("mode") is DON'T CARE" for AFs others than GPIO pin_config ((pin_obj_t *)&pin_GPIO1, PIN_MODE_3, 0, PIN_TYPE_STD_PU, PIN_STRENGTH_2MA); pin_config ((pin_obj_t *)&pin_GPIO2, PIN_MODE_3, 0, PIN_TYPE_STD_PU, PIN_STRENGTH_2MA); // instantiate the stdio uart mp_obj_t args[2] = { mp_obj_new_int(MICROPY_STDIO_UART), mp_obj_new_int(MICROPY_STDIO_UART_BAUD), }; pyb_stdio_uart = pyb_uart_type.make_new((mp_obj_t)&pyb_uart_type, MP_ARRAY_SIZE(args), 0, args); // create a callback for the uart, in order to enable the rx interrupts uart_callback_new (pyb_stdio_uart, mp_const_none, MICROPY_STDIO_UART_RX_BUF_SIZE, INT_PRIORITY_LVL_3); #else pyb_stdio_uart = MP_OBJ_NULL; #endif pybsleep_reset_cause_t rstcause = pybsleep_get_reset_cause(); if (rstcause < PYB_SLP_SOFT_RESET) { if (rstcause == PYB_SLP_HIB_RESET) { // when waking up from hibernate we just want // to enable simplelink and leave it as is wlan_first_start(); } else { // only if not comming out of hibernate or a soft reset mptask_enter_ap_mode(); #ifndef DEBUG safeboot = PRCMIsSafeBootRequested(); #endif } // enable telnet and ftp servers_start(); } // initialize the serial flash file system mptask_init_sflash_filesystem(); // append the flash paths to the system path mp_obj_list_append(mp_sys_path, MP_OBJ_NEW_QSTR(MP_QSTR__slash_flash)); mp_obj_list_append(mp_sys_path, MP_OBJ_NEW_QSTR(MP_QSTR__slash_flash_slash_lib)); // reset config variables; they should be set by boot.py MP_STATE_PORT(pyb_config_main) = MP_OBJ_NULL; if (!safeboot) { // run boot.py, if it exists const char *boot_py = "boot.py"; res = f_stat(boot_py, NULL); if (res == FR_OK) { int ret = pyexec_file(boot_py); if (ret & PYEXEC_FORCED_EXIT) { goto soft_reset_exit; } if (!ret) { // flash the system led mperror_signal_error(); } } } // now we initialise sub-systems that need configuration from boot.py, // or whose initialisation can be safely deferred until after running // boot.py. // at this point everything is fully configured and initialised. if (!safeboot) { // run the main script from the current directory. if (pyexec_mode_kind == PYEXEC_MODE_FRIENDLY_REPL) { const char *main_py; if (MP_STATE_PORT(pyb_config_main) == MP_OBJ_NULL) { main_py = "main.py"; } else { main_py = mp_obj_str_get_str(MP_STATE_PORT(pyb_config_main)); } res = f_stat(main_py, NULL); if (res == FR_OK) { int ret = pyexec_file(main_py); if (ret & PYEXEC_FORCED_EXIT) { goto soft_reset_exit; } if (!ret) { // flash the system led mperror_signal_error(); } } } } // main script is finished, so now go into REPL mode. // the REPL mode can change, or it can request a soft reset. for ( ; ; ) { if (pyexec_mode_kind == PYEXEC_MODE_RAW_REPL) { if (pyexec_raw_repl() != 0) { break; } } else { if (pyexec_friendly_repl() != 0) { break; } } } soft_reset_exit: // soft reset pybsleep_signal_soft_reset(); mp_printf(&mp_plat_print, "PYB: soft reboot\n"); sflash_disk_flush(); #if MICROPY_HW_HAS_SDCARD pybsd_deinit(); #endif goto soft_reset; }
STATIC mp_obj_t machine_wake_reason (void) { return mp_obj_new_int(pyb_sleep_get_wake_reason()); }
/// \function freq([sys_freq]) /// /// If given no arguments, returns a tuple of clock frequencies: /// (SYSCLK, HCLK, PCLK1, PCLK2). /// /// If given an argument, sets the system frequency to that value in Hz. /// Eg freq(120000000) gives 120MHz. Note that not all values are /// supported and the largest supported frequency not greater than /// the given sys_freq will be selected. STATIC mp_obj_t pyb_freq(mp_uint_t n_args, const mp_obj_t *args) { if (n_args == 0) { // get 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); } else { // set mp_int_t wanted_sysclk = mp_obj_get_int(args[0]) / 1000000; // default PLL parameters that give 48MHz on PLL48CK uint32_t m = HSE_VALUE / 1000000, n = 336, p = 2, q = 7; uint32_t sysclk_source; // the following logic assumes HSE < HSI if (HSE_VALUE / 1000000 <= wanted_sysclk && wanted_sysclk < HSI_VALUE / 1000000) { // use HSE as SYSCLK sysclk_source = RCC_SYSCLKSOURCE_HSE; } else if (HSI_VALUE / 1000000 <= wanted_sysclk && wanted_sysclk < 24) { // use HSI as SYSCLK sysclk_source = RCC_SYSCLKSOURCE_HSI; } else { // search for a valid PLL configuration that keeps USB at 48MHz for (; wanted_sysclk > 0; wanted_sysclk--) { for (p = 2; p <= 8; p += 2) { // compute VCO_OUT mp_uint_t vco_out = wanted_sysclk * p; // make sure VCO_OUT is between 192MHz and 432MHz if (vco_out < 192 || vco_out > 432) { continue; } // make sure Q is an integer if (vco_out % 48 != 0) { continue; } // solve for Q to get PLL48CK at 48MHz q = vco_out / 48; // make sure Q is in range if (q < 2 || q > 15) { continue; } // make sure N/M is an integer if (vco_out % (HSE_VALUE / 1000000) != 0) { continue; } // solve for N/M mp_uint_t n_by_m = vco_out / (HSE_VALUE / 1000000); // solve for M, making sure VCO_IN (=HSE/M) is between 1MHz and 2MHz m = 192 / n_by_m; while (m < (HSE_VALUE / 2000000) || n_by_m * m < 192) { m += 1; } if (m > (HSE_VALUE / 1000000)) { continue; } // solve for N n = n_by_m * m; // make sure N is in range if (n < 192 || n > 432) { continue; } // found values! sysclk_source = RCC_SYSCLKSOURCE_PLLCLK; goto set_clk; } } nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, "can't make valid freq")); } set_clk: //printf("%lu %lu %lu %lu %lu\n", sysclk_source, m, n, p, q); // let the USB CDC have a chance to process before we change the clock HAL_Delay(USBD_CDC_POLLING_INTERVAL + 2); // desired system clock source is in sysclk_source RCC_ClkInitTypeDef RCC_ClkInitStruct; RCC_ClkInitStruct.ClockType = (RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2); if (sysclk_source == RCC_SYSCLKSOURCE_PLLCLK) { // set HSE as system clock source to allow modification of the PLL configuration // we then change to PLL after re-configuring PLL RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSE; } else { // directly set the system clock source as desired RCC_ClkInitStruct.SYSCLKSource = sysclk_source; } RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1; RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4; RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2; if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_1) != HAL_OK) { goto fail; } // re-configure PLL // even if we don't use the PLL for the system clock, we still need it for USB, RNG and SDIO RCC_OscInitTypeDef RCC_OscInitStruct; RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE; RCC_OscInitStruct.HSEState = RCC_HSE_ON; RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON; RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE; RCC_OscInitStruct.PLL.PLLM = m; RCC_OscInitStruct.PLL.PLLN = n; RCC_OscInitStruct.PLL.PLLP = p; RCC_OscInitStruct.PLL.PLLQ = q; if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK) { goto fail; } // set PLL as system clock source if wanted if (sysclk_source == RCC_SYSCLKSOURCE_PLLCLK) { RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_SYSCLK; RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK; if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_5) != HAL_OK) { goto fail; } } // re-init TIM3 for USB CDC rate timer_tim3_init(); return mp_const_none; fail:; void NORETURN __fatal_error(const char *msg); __fatal_error("can't change freq"); } }
int main(int argc, char **argv) { volatile int stack_dummy; stack_top = (void*)&stack_dummy; pre_process_options(argc, argv); #if MICROPY_ENABLE_GC char *heap = malloc(heap_size); gc_init(heap, heap + heap_size); #endif qstr_init(); mp_init(); char *home = getenv("HOME"); char *path = getenv("MICROPYPATH"); if (path == NULL) { path = "~/.micropython/lib:/usr/lib/micropython"; } uint path_num = 1; // [0] is for current dir (or base dir of the script) for (char *p = path; p != NULL; p = strchr(p, ':')) { path_num++; if (p != NULL) { p++; } } mp_obj_list_init(mp_sys_path, path_num); mp_obj_t *path_items; mp_obj_list_get(mp_sys_path, &path_num, &path_items); path_items[0] = MP_OBJ_NEW_QSTR(MP_QSTR_); char *p = path; for (int i = 1; i < path_num; i++) { char *p1 = strchr(p, ':'); if (p1 == NULL) { p1 = p + strlen(p); } if (p[0] == '~' && p[1] == '/' && home != NULL) { // Expand standalone ~ to $HOME CHECKBUF(buf, PATH_MAX); CHECKBUF_APPEND(buf, home, strlen(home)); CHECKBUF_APPEND(buf, p + 1, p1 - p - 1); path_items[i] = MP_OBJ_NEW_QSTR(qstr_from_strn(buf, CHECKBUF_LEN(buf))); } else { path_items[i] = MP_OBJ_NEW_QSTR(qstr_from_strn(p, p1 - p)); } p = p1 + 1; } mp_obj_list_init(mp_sys_argv, 0); mp_store_name(qstr_from_str("test"), test_obj_new(42)); mp_store_name(qstr_from_str("mem_info"), mp_make_function_n(0, mem_info)); mp_store_name(qstr_from_str("qstr_info"), mp_make_function_n(0, qstr_info)); #if MICROPY_ENABLE_GC mp_store_name(qstr_from_str("gc"), (mp_obj_t)&pyb_gc_obj); #endif // Here is some example code to create a class and instance of that class. // First is the Python, then the C code. // // class TestClass: // pass // test_obj = TestClass() // test_obj.attr = 42 mp_obj_t test_class_type, test_class_instance; test_class_type = mp_obj_new_type(QSTR_FROM_STR_STATIC("TestClass"), mp_const_empty_tuple, mp_obj_new_dict(0)); mp_store_name(QSTR_FROM_STR_STATIC("test_obj"), test_class_instance = mp_call_function_0(test_class_type)); mp_store_attr(test_class_instance, QSTR_FROM_STR_STATIC("attr"), mp_obj_new_int(42)); /* printf("bytes:\n"); printf(" total %d\n", m_get_total_bytes_allocated()); printf(" cur %d\n", m_get_current_bytes_allocated()); printf(" peak %d\n", m_get_peak_bytes_allocated()); */ bool executed = false; for (int a = 1; a < argc; a++) { if (argv[a][0] == '-') { if (strcmp(argv[a], "-c") == 0) { if (a + 1 >= argc) { return usage(argv); } do_str(argv[a + 1]); executed = true; a += 1; } else if (strcmp(argv[a], "-X") == 0) { a += 1; } else { return usage(argv); } } else { char *basedir = realpath(argv[a], NULL); if (basedir == NULL) { fprintf(stderr, "%s: can't open file '%s': [Errno %d] ", argv[0], argv[1], errno); perror(""); // CPython exits with 2 in such case exit(2); } // Set base dir of the script as first entry in sys.path char *p = strrchr(basedir, '/'); path_items[0] = MP_OBJ_NEW_QSTR(qstr_from_strn(basedir, p - basedir)); free(basedir); for (int i = a; i < argc; i++) { mp_obj_list_append(mp_sys_argv, MP_OBJ_NEW_QSTR(qstr_from_str(argv[i]))); } do_file(argv[a]); executed = true; break; } } if (!executed) { do_repl(); } mp_deinit(); //printf("total bytes = %d\n", m_get_total_bytes_allocated()); return 0; }
STATIC mp_obj_t mp_irq_flags (mp_obj_t self_in) { mp_irq_obj_t *self = self_in; return mp_obj_new_int(self->methods->flags(self->parent)); }
mp_obj_t microbit_compass_get_z(mp_obj_t self_in) { microbit_compass_obj_t *self = (microbit_compass_obj_t*)self_in; return mp_obj_new_int(self->compass->getZ()); }
STATIC mp_obj_t call_method(jobject obj, const char *name, jarray methods, bool is_constr, mp_uint_t n_args, const mp_obj_t *args) { jvalue jargs[n_args]; // printf("methods=%p\n", methods); jsize num_methods = JJ(GetArrayLength, methods); for (int i = 0; i < num_methods; i++) { jobject meth = JJ(GetObjectArrayElement, methods, i); jobject name_o = JJ(CallObjectMethod, meth, Object_toString_mid); const char *decl = JJ(GetStringUTFChars, name_o, NULL); const char *arg_types = strchr(decl, '(') + 1; //const char *arg_types_end = strchr(arg_types, ')'); // printf("method[%d]=%p %s\n", i, meth, decl); const char *meth_name = NULL; const char *ret_type = NULL; if (!is_constr) { meth_name = strprev(arg_types, '.') + 1; ret_type = strprev(meth_name, ' ') - 1; ret_type = strprev(ret_type, ' ') + 1; int name_len = strlen(name); if (strncmp(name, meth_name, name_len/*arg_types - meth_name - 1*/) || meth_name[name_len] != '('/*(*/) { goto next_method; } } // printf("method[%d]=%p %s\n", i, meth, decl); // printf("!!!%s\n", arg_types); // printf("name=%p meth_name=%s\n", name, meth_name); bool found = true; for (int i = 0; i < n_args && *arg_types != ')'; i++) { if (!py2jvalue(&arg_types, args[i], &jargs[i])) { goto next_method; } if (*arg_types == ',') { arg_types++; } } if (*arg_types != ')') { goto next_method; } if (found) { // printf("found!\n"); jmethodID method_id = JJ(FromReflectedMethod, meth); jobject res; mp_obj_t ret; if (is_constr) { JJ(ReleaseStringUTFChars, name_o, decl); res = JJ(NewObjectA, obj, method_id, jargs); return new_jobject(res); } else { if (MATCH(ret_type, "void")) { JJ(CallVoidMethodA, obj, method_id, jargs); check_exception(); ret = mp_const_none; } else if (MATCH(ret_type, "int")) { jint res = JJ(CallIntMethodA, obj, method_id, jargs); check_exception(); ret = mp_obj_new_int(res); } else if (MATCH(ret_type, "boolean")) { jboolean res = JJ(CallBooleanMethodA, obj, method_id, jargs); check_exception(); ret = mp_obj_new_bool(res); } else if (is_object_type(ret_type)) { res = JJ(CallObjectMethodA, obj, method_id, jargs); check_exception(); ret = new_jobject(res); } else { JJ(ReleaseStringUTFChars, name_o, decl); nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "cannot handle return type")); } JJ(ReleaseStringUTFChars, name_o, decl); JJ(DeleteLocalRef, name_o); JJ(DeleteLocalRef, meth); return ret; } } next_method: JJ(ReleaseStringUTFChars, name_o, decl); JJ(DeleteLocalRef, name_o); JJ(DeleteLocalRef, meth); } nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "method not found")); }
STATIC mp_obj_t mod_citrus_ptmsysm_init(void) { INIT_ONCE(_mod_citrus_ptmsysm_is_init); return mp_obj_new_int(ptmSysmInit()); }
STATIC mp_obj_t mod_jni_env() { return mp_obj_new_int((mp_int_t)env); }
/// \method tilt() /// Get the tilt register. STATIC mp_obj_t pyb_accel_tilt(mp_obj_t self_in) { uint8_t data[1]; HAL_I2C_Mem_Read(&I2CHandle1, MMA_ADDR, MMA_REG_TILT, I2C_MEMADD_SIZE_8BIT, data, 1, 200); return mp_obj_new_int(data[0]); }
STATIC mp_obj_t esp_socket_getaddrinfo(size_t n_args, const mp_obj_t *args) { // TODO support additional args beyond the first two struct addrinfo *res = NULL; _socket_getaddrinfo2(args[0], args[1], &res); mp_obj_t ret_list = mp_obj_new_list(0, NULL); for (struct addrinfo *resi = res; resi; resi = resi->ai_next) { mp_obj_t addrinfo_objs[5] = { mp_obj_new_int(resi->ai_family), mp_obj_new_int(resi->ai_socktype), mp_obj_new_int(resi->ai_protocol), mp_obj_new_str(resi->ai_canonname, strlen(resi->ai_canonname)), mp_const_none }; if (resi->ai_family == AF_INET) { struct sockaddr_in *addr = (struct sockaddr_in *)resi->ai_addr; // This looks odd, but it's really just a u32_t ip4_addr_t ip4_addr = { .addr = addr->sin_addr.s_addr }; char buf[16]; ip4addr_ntoa_r(&ip4_addr, buf, sizeof(buf)); mp_obj_t inaddr_objs[2] = { mp_obj_new_str(buf, strlen(buf)), mp_obj_new_int(ntohs(addr->sin_port)) }; addrinfo_objs[4] = mp_obj_new_tuple(2, inaddr_objs); } mp_obj_list_append(ret_list, mp_obj_new_tuple(5, addrinfo_objs)); } if (res) lwip_freeaddrinfo(res); return ret_list; } STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(esp_socket_getaddrinfo_obj, 2, 6, esp_socket_getaddrinfo); STATIC mp_obj_t esp_socket_initialize() { static int initialized = 0; if (!initialized) { ESP_LOGI("modsocket", "Initializing"); tcpip_adapter_init(); initialized = 1; } return mp_const_none; } STATIC MP_DEFINE_CONST_FUN_OBJ_0(esp_socket_initialize_obj, esp_socket_initialize); STATIC const mp_map_elem_t mp_module_socket_globals_table[] = { { MP_OBJ_NEW_QSTR(MP_QSTR___name__), MP_OBJ_NEW_QSTR(MP_QSTR_usocket) }, { MP_OBJ_NEW_QSTR(MP_QSTR___init__), (mp_obj_t)&esp_socket_initialize_obj }, { MP_OBJ_NEW_QSTR(MP_QSTR_socket), (mp_obj_t)&get_socket_obj }, { MP_OBJ_NEW_QSTR(MP_QSTR_getaddrinfo), (mp_obj_t)&esp_socket_getaddrinfo_obj }, { MP_OBJ_NEW_QSTR(MP_QSTR_AF_INET), MP_OBJ_NEW_SMALL_INT(AF_INET) }, { MP_OBJ_NEW_QSTR(MP_QSTR_AF_INET6), MP_OBJ_NEW_SMALL_INT(AF_INET6) }, { MP_OBJ_NEW_QSTR(MP_QSTR_SOCK_STREAM), MP_OBJ_NEW_SMALL_INT(SOCK_STREAM) }, { MP_OBJ_NEW_QSTR(MP_QSTR_SOCK_DGRAM), MP_OBJ_NEW_SMALL_INT(SOCK_DGRAM) }, { MP_OBJ_NEW_QSTR(MP_QSTR_SOCK_RAW), MP_OBJ_NEW_SMALL_INT(SOCK_RAW) }, { MP_OBJ_NEW_QSTR(MP_QSTR_IPPROTO_TCP), MP_OBJ_NEW_SMALL_INT(IPPROTO_TCP) }, { MP_OBJ_NEW_QSTR(MP_QSTR_IPPROTO_UDP), MP_OBJ_NEW_SMALL_INT(IPPROTO_UDP) }, { MP_OBJ_NEW_QSTR(MP_QSTR_IPPROTO_IP), MP_OBJ_NEW_SMALL_INT(IPPROTO_IP) }, { MP_OBJ_NEW_QSTR(MP_QSTR_SOL_SOCKET), MP_OBJ_NEW_SMALL_INT(SOL_SOCKET) }, { MP_OBJ_NEW_QSTR(MP_QSTR_SO_REUSEADDR), MP_OBJ_NEW_SMALL_INT(SO_REUSEADDR) }, { MP_OBJ_NEW_QSTR(MP_QSTR_IP_ADD_MEMBERSHIP), MP_OBJ_NEW_SMALL_INT(IP_ADD_MEMBERSHIP) }, }; STATIC MP_DEFINE_CONST_DICT(mp_module_socket_globals, mp_module_socket_globals_table); const mp_obj_module_t mp_module_usocket = { .base = { &mp_type_module }, .globals = (mp_obj_dict_t*)&mp_module_socket_globals, };