code stringlengths 1 1.05M | repo_name stringlengths 6 83 | path stringlengths 3 242 | language stringclasses 222 values | license stringclasses 20 values | size int64 1 1.05M |
|---|---|---|---|---|---|
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2014-2018 Paul Sokolovsky
* Copyright (c) 2014-2018 Damien P. George
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <dirent.h>
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include "dirent.h"
#if MICROPY_VFS_FAT
#include "lib/oofatfs/diskio.h"
#include "lib/oofatfs/ff.h"
#endif
#include "esp_log.h"
#include "extmod/misc.h"
#include "extmod/vfs.h"
#include "genhdr/mpversion.h"
#include "py/mpconfig.h"
#include "py/mperrno.h"
#include "py/mphal.h"
#include "py/mpthread.h"
#include "py/objstr.h"
#include "py/objtuple.h"
#include "py/runtime.h"
#if MICROPY_VFS_POSIX
#include "extmod/vfs_posix.h"
#endif
#define TAG "MOD_OS"
extern const mp_obj_type_t mp_fat_vfs_type;
STATIC const qstr os_uname_info_fields[] = { MP_QSTR_sysname, MP_QSTR_nodename, MP_QSTR_release, MP_QSTR_version,
MP_QSTR_machine };
STATIC const MP_DEFINE_STR_OBJ(os_uname_info_sysname_obj, MICROPY_PY_SYS_PLATFORM);
STATIC const MP_DEFINE_STR_OBJ(os_uname_info_nodename_obj, MICROPY_PY_SYS_NODE);
STATIC const MP_DEFINE_STR_OBJ(os_uname_info_release_obj, MICROPY_VERSION_STRING);
STATIC const MP_DEFINE_STR_OBJ(os_uname_info_version_obj, MICROPY_GIT_TAG " on " MICROPY_BUILD_DATE);
STATIC const MP_DEFINE_STR_OBJ(os_uname_info_machine_obj, MICROPY_HW_BOARD_NAME " with " MICROPY_HW_MCU_NAME);
STATIC MP_DEFINE_ATTRTUPLE(os_uname_info_obj, os_uname_info_fields, 5, (mp_obj_t)&os_uname_info_sysname_obj,
(mp_obj_t)&os_uname_info_nodename_obj, (mp_obj_t)&os_uname_info_release_obj,
(mp_obj_t)&os_uname_info_version_obj, (mp_obj_t)&os_uname_info_machine_obj);
STATIC mp_obj_t os_uname(void)
{
return (mp_obj_t)&os_uname_info_obj;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_0(os_uname_obj, os_uname);
STATIC mp_obj_t os_version(void)
{
char version[40] = { 0 };
sprintf(version, "%s-v%s", MICROPY_SW_VENDOR_NAME, SYSINFO_SYSTEM_VERSION);
return mp_obj_new_str(version, strlen(version));
}
STATIC MP_DEFINE_CONST_FUN_OBJ_0(os_version_obj, os_version);
STATIC mp_obj_t os_version_info(void)
{
char version_info[80] = { 0 };
#ifdef MICROPY_HW_BOARD_TYPE
sprintf(version_info, "%s-%s-%s-v%s-%s", MICROPY_SW_VENDOR_NAME, MICROPY_HW_MCU_NAME, MICROPY_HW_BOARD_TYPE,
SYSINFO_SYSTEM_VERSION, MICROPY_BUILD_DATE);
#else
sprintf(version_info, "%s-%s-v%s-%s", MICROPY_SW_VENDOR_NAME, MICROPY_HW_MCU_NAME, SYSINFO_SYSTEM_VERSION,
MICROPY_BUILD_DATE);
#endif
return mp_obj_new_str(version_info, strlen(version_info));
}
STATIC MP_DEFINE_CONST_FUN_OBJ_0(os_version_info_obj, os_version_info);
STATIC mp_obj_t os_urandom(mp_obj_t num)
{
mp_int_t n = mp_obj_get_int(num);
vstr_t vstr;
vstr_init_len(&vstr, n);
mp_uint_t r = 0;
for (int i = 0; i < n; i++) {
if ((i & 3) == 0) {
r = rand();
}
vstr.buf[i] = r;
r >>= 8;
}
vstr.buf[n] = '\0';
return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(os_urandom_obj, os_urandom);
#if MICROPY_PY_OS_DUPTERM
STATIC mp_obj_t os_dupterm_notify(mp_obj_t obj_in)
{
(void)obj_in;
for (;;) {
int c = mp_uos_dupterm_rx_chr();
if (c < 0) {
break;
}
ringbuf_put(&stdin_ringbuf, c);
mp_hal_wake_main_task_from_isr();
}
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(os_dupterm_notify_obj, os_dupterm_notify);
#endif
extern void aos_task_show_info();
STATIC mp_obj_t mod_os_tasklist(void)
{
aos_task_show_info();
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_0(mod_os_tasklist_obj, mod_os_tasklist);
#ifdef CONFIG_ESP32_SOMELIBS_BSS_ON_IRAM_8BIT
extern int _iram_8bit_bss_start, _iram_8bit_bss_end;
#endif
#ifdef CONFIG_SPIRAM_ALLOW_BSS_SEG_EXTERNAL_MEMORY
extern int _ext_ram_bss_start, _ext_ram_bss_end;
#endif
extern int _data_start, _heap_start, _iram_start, _iram_end;
extern void aos_mm_show_info(void);
size_t heap_caps_get_free_size(uint32_t caps);
STATIC mp_obj_t mod_os_dumpsys_mm(void)
{
printf("\r\n COMPILE-TIME MEMORY STATISTICS \r\n");
printf("\r\n[bss/data on internal-dram-8bit]\r\n");
printf("%lu\r\n", (unsigned long)&_heap_start - (unsigned long)&_data_start);
#ifdef CONFIG_ESP32_SOMELIBS_BSS_ON_IRAM_8BIT
printf("\r\n[bss on internal-iram-8bit]\r\n");
printf("%lu\r\n", (unsigned long)&_iram_8bit_bss_end - (unsigned long)&_iram_8bit_bss_start);
#endif
#ifdef CONFIG_SPIRAM_ALLOW_BSS_SEG_EXTERNAL_MEMORY
printf("\r\n[bss on external-spiram]\r\n");
printf("%lu\r\n", (unsigned long)&_ext_ram_bss_end - (unsigned long)&_ext_ram_bss_start);
#endif
printf("\r\n[text on internal-iram]\r\n");
printf("%lu\r\n", (unsigned long)&_iram_end - (unsigned long)&_iram_start);
printf("\r\n RUN-TIME MEMORY STATICTICS\r\n");
aos_mm_show_info();
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_0(mod_os_dumpsys_mm_obj, mod_os_dumpsys_mm);
STATIC mp_obj_t mod_os_plussys_mm(void)
{
#if CONFIG_BT_ENABLED
#include "esp_bt.h"
esp_bt_mem_release(ESP_BT_MODE_BTDM);
#endif
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_0(mod_os_plussys_mm_obj, mod_os_plussys_mm);
#include "esp_heap_caps.h"
STATIC mp_obj_t os_heap(void)
{
printf("[free-defaut] %d\r\n", esp_get_free_heap_size());
printf("[free-8bit-internal] %d\r\n", heap_caps_get_free_size(MALLOC_CAP_8BIT | MALLOC_CAP_INTERNAL));
#if CONFIG_SPIRAM_USE_MALLOC
printf("[free-8bit-spiram] %d\r\n", heap_caps_get_free_size(MALLOC_CAP_8BIT | MALLOC_CAP_SPIRAM));
#endif
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_0(os_heap_obj, os_heap);
STATIC const mp_rom_map_elem_t os_module_globals_table[] = {
{ MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_uos) },
{ MP_ROM_QSTR(MP_QSTR_uname), MP_ROM_PTR(&os_uname_obj) },
{ MP_ROM_QSTR(MP_QSTR_urandom), MP_ROM_PTR(&os_urandom_obj) },
{ MP_ROM_QSTR(MP_QSTR_version), MP_ROM_PTR(&os_version_obj) },
{ MP_ROM_QSTR(MP_QSTR_version_info), MP_ROM_PTR(&os_version_info_obj) },
#if MICROPY_PY_OS_DUPTERM
{ MP_ROM_QSTR(MP_QSTR_dupterm), MP_ROM_PTR(&mp_uos_dupterm_obj) },
{ MP_ROM_QSTR(MP_QSTR_dupterm_notify), MP_ROM_PTR(&os_dupterm_notify_obj) },
#endif
#if MICROPY_VFS
{ MP_ROM_QSTR(MP_QSTR_listdir), MP_ROM_PTR(&mp_vfs_listdir_obj) },
{ MP_ROM_QSTR(MP_QSTR_ilistdir), MP_ROM_PTR(&mp_vfs_ilistdir_obj) },
{ MP_ROM_QSTR(MP_QSTR_mkdir), MP_ROM_PTR(&mp_vfs_mkdir_obj) },
{ MP_ROM_QSTR(MP_QSTR_rmdir), MP_ROM_PTR(&mp_vfs_rmdir_obj) },
{ MP_ROM_QSTR(MP_QSTR_chdir), MP_ROM_PTR(&mp_vfs_chdir_obj) },
{ MP_ROM_QSTR(MP_QSTR_getcwd), MP_ROM_PTR(&mp_vfs_getcwd_obj) },
{ MP_ROM_QSTR(MP_QSTR_remove), MP_ROM_PTR(&mp_vfs_remove_obj) },
{ MP_ROM_QSTR(MP_QSTR_rename), MP_ROM_PTR(&mp_vfs_rename_obj) },
{ MP_ROM_QSTR(MP_QSTR_stat), MP_ROM_PTR(&mp_vfs_stat_obj) },
{ MP_ROM_QSTR(MP_QSTR_statvfs), MP_ROM_PTR(&mp_vfs_statvfs_obj) },
{ MP_ROM_QSTR(MP_QSTR_mount), MP_ROM_PTR(&mp_vfs_mount_obj) },
{ MP_ROM_QSTR(MP_QSTR_umount), MP_ROM_PTR(&mp_vfs_umount_obj) },
#if MICROPY_VFS_POSIX
{ MP_ROM_QSTR(MP_QSTR_VfsPosix), MP_ROM_PTR(&mp_type_vfs_posix) },
#endif
#if MICROPY_VFS_FAT
{ MP_ROM_QSTR(MP_QSTR_VfsFat), MP_ROM_PTR(&mp_fat_vfs_type) },
#endif
#if MICROPY_VFS_LFS1
{ MP_ROM_QSTR(MP_QSTR_VfsLfs1), MP_ROM_PTR(&mp_type_vfs_lfs1) },
#endif
#if MICROPY_VFS_LFS2
{ MP_ROM_QSTR(MP_QSTR_VfsLfs2), MP_ROM_PTR(&mp_type_vfs_lfs2) },
#endif
#endif
{ MP_ROM_QSTR(MP_QSTR_heap), MP_ROM_PTR(&os_heap_obj) },
{ MP_ROM_QSTR(MP_QSTR_tasklist), MP_ROM_PTR(&mod_os_tasklist_obj) },
{ MP_ROM_QSTR(MP_QSTR_dumpsys_mm), MP_ROM_PTR(&mod_os_dumpsys_mm_obj) },
{ MP_ROM_QSTR(MP_QSTR_plussys_mm), MP_ROM_PTR(&mod_os_plussys_mm_obj) },
};
STATIC MP_DEFINE_CONST_DICT(os_module_globals, os_module_globals_table);
const mp_obj_module_t uos_module = {
.base = { &mp_type_module },
.globals = (mp_obj_dict_t *)&os_module_globals,
};
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/moduos.c | C | apache-2.0 | 9,241 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* Development of the code in this file was sponsored by Microbric Pty Ltd
*
* The MIT License (MIT)
*
* Copyright (c) 2016 Damien P. George
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <stdio.h>
#include <string.h>
#include <sys/time.h>
#include "py/runtime.h"
#include "shared/timeutils/timeutils.h"
#include "extmod/utime_mphal.h"
STATIC mp_obj_t time_localtime(size_t n_args, const mp_obj_t *args) {
timeutils_struct_time_t tm;
mp_int_t seconds;
if (n_args == 0 || args[0] == mp_const_none) {
struct timeval tv;
gettimeofday(&tv, NULL);
seconds = tv.tv_sec;
} else {
seconds = mp_obj_get_int(args[0]);
}
timeutils_seconds_since_epoch_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);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(time_localtime_obj, 0, 1, time_localtime);
STATIC mp_obj_t time_mktime(mp_obj_t tuple) {
size_t len;
mp_obj_t *elem;
mp_obj_get_array(tuple, &len, &elem);
// localtime generates a tuple of len 8. CPython uses 9, so we accept both.
if (len < 8 || len > 9) {
mp_raise_msg_varg(&mp_type_TypeError, MP_ERROR_TEXT("mktime needs a tuple of length 8 or 9 (%d given)"), len);
}
return mp_obj_new_int_from_uint(timeutils_mktime(mp_obj_get_int(elem[0]),
mp_obj_get_int(elem[1]), mp_obj_get_int(elem[2]), mp_obj_get_int(elem[3]),
mp_obj_get_int(elem[4]), mp_obj_get_int(elem[5])));
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(time_mktime_obj, time_mktime);
STATIC mp_obj_t time_time(void) {
struct timeval tv;
gettimeofday(&tv, NULL);
return mp_obj_new_int(tv.tv_sec);
}
MP_DEFINE_CONST_FUN_OBJ_0(time_time_obj, time_time);
STATIC const mp_rom_map_elem_t time_module_globals_table[] = {
{ MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_utime) },
{ MP_ROM_QSTR(MP_QSTR_gmtime), MP_ROM_PTR(&time_localtime_obj) },
{ MP_ROM_QSTR(MP_QSTR_localtime), MP_ROM_PTR(&time_localtime_obj) },
{ MP_ROM_QSTR(MP_QSTR_mktime), MP_ROM_PTR(&time_mktime_obj) },
{ MP_ROM_QSTR(MP_QSTR_time), MP_ROM_PTR(&time_time_obj) },
{ MP_ROM_QSTR(MP_QSTR_sleep), MP_ROM_PTR(&mp_utime_sleep_obj) },
{ MP_ROM_QSTR(MP_QSTR_sleep_ms), MP_ROM_PTR(&mp_utime_sleep_ms_obj) },
{ MP_ROM_QSTR(MP_QSTR_sleep_us), MP_ROM_PTR(&mp_utime_sleep_us_obj) },
{ MP_ROM_QSTR(MP_QSTR_ticks_ms), MP_ROM_PTR(&mp_utime_ticks_ms_obj) },
{ MP_ROM_QSTR(MP_QSTR_ticks_us), MP_ROM_PTR(&mp_utime_ticks_us_obj) },
{ MP_ROM_QSTR(MP_QSTR_ticks_cpu), MP_ROM_PTR(&mp_utime_ticks_cpu_obj) },
{ MP_ROM_QSTR(MP_QSTR_ticks_add), MP_ROM_PTR(&mp_utime_ticks_add_obj) },
{ MP_ROM_QSTR(MP_QSTR_ticks_diff), MP_ROM_PTR(&mp_utime_ticks_diff_obj) },
{ MP_ROM_QSTR(MP_QSTR_time_ns), MP_ROM_PTR(&mp_utime_time_ns_obj) },
};
STATIC MP_DEFINE_CONST_DICT(time_module_globals, time_module_globals_table);
const mp_obj_module_t utime_module = {
.base = { &mp_type_module },
.globals = (mp_obj_dict_t *)&time_module_globals,
};
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/modutime.c | C | apache-2.0 | 4,506 |
// Options to control how MicroPython is built for this port,
// overriding defaults in py/mpconfig.h.
// Board-specific definitions
#include "mpconfigboard.h"
#include <stdint.h>
#include <alloca.h>
#include "esp_system.h"
#include "freertos/FreeRTOS.h"
// #include "driver/i2s.h"
// object representation and NLR handling
#define MICROPY_OBJ_REPR (MICROPY_OBJ_REPR_A)
#define MICROPY_NLR_SETJMP (1)
#if CONFIG_IDF_TARGET_ESP32C3
#define MICROPY_GCREGS_SETJMP (1)
#endif
// memory allocation policies
#define MICROPY_ALLOC_PATH_MAX (128)
// emitters
#define MICROPY_PERSISTENT_CODE_LOAD (1)
#if !CONFIG_IDF_TARGET_ESP32C3
#define MICROPY_EMIT_XTENSAWIN (1)
#endif
// compiler configuration
#define MICROPY_COMP_MODULE_CONST (1)
#define MICROPY_COMP_TRIPLE_TUPLE_ASSIGN (1)
// optimisations
#define MICROPY_OPT_COMPUTED_GOTO (1)
#define MICROPY_OPT_MPZ_BITWISE (1)
// Python internal features
#define MICROPY_READER_VFS (1)
#define MICROPY_ENABLE_GC (1)
#define MICROPY_ENABLE_FINALISER (1)
#define MICROPY_STACK_CHECK (1)
#define MICROPY_ENABLE_EMERGENCY_EXCEPTION_BUF (1)
#define MICROPY_KBD_EXCEPTION (1)
#define MICROPY_HELPER_REPL (1)
#define MICROPY_REPL_EMACS_KEYS (1)
#define MICROPY_REPL_AUTO_INDENT (1)
#define MICROPY_LONGINT_IMPL (MICROPY_LONGINT_IMPL_MPZ)
#define MICROPY_ENABLE_SOURCE_LINE (1)
#define MICROPY_ERROR_REPORTING (MICROPY_ERROR_REPORTING_NORMAL)
#define MICROPY_WARNINGS (1)
#define MICROPY_FLOAT_IMPL (MICROPY_FLOAT_IMPL_FLOAT)
#define MICROPY_CPYTHON_COMPAT (1)
#define MICROPY_STREAMS_NON_BLOCK (1)
#define MICROPY_STREAMS_POSIX_API (1)
#define MICROPY_MODULE_BUILTIN_INIT (1)
#define MICROPY_MODULE_WEAK_LINKS (1)
#define MICROPY_MODULE_FROZEN_STR (0)
#define MICROPY_MODULE_FROZEN_MPY (1)
#define MICROPY_QSTR_EXTRA_POOL mp_qstr_frozen_const_pool
#define MICROPY_CAN_OVERRIDE_BUILTINS (1)
#define MICROPY_USE_INTERNAL_ERRNO (0) // errno.h from xtensa-esp32-elf/sys-include/sys
#define MICROPY_USE_INTERNAL_PRINTF (0) // ESP32 SDK requires its own printf
#define MICROPY_ENABLE_SCHEDULER (1)
#define MICROPY_SCHEDULER_DEPTH (8 * 2)
#define MICROPY_VFS (1)
#define MICROPY_VFS_POSIX (1)
#define MICROPY_VFS_FAT (1)
#define MICROPY_FATFS_NORTC (1)
// control over Python builtins
#define MICROPY_PY_FUNCTION_ATTRS (1)
#define MICROPY_PY_DESCRIPTORS (1)
#define MICROPY_PY_DELATTR_SETATTR (1)
#define MICROPY_PY_FSTRINGS (1)
#define MICROPY_PY_STR_BYTES_CMP_WARN (1)
#define MICROPY_PY_BUILTINS_STR_UNICODE (1)
#define MICROPY_PY_BUILTINS_STR_CENTER (1)
#define MICROPY_PY_BUILTINS_STR_PARTITION (1)
#define MICROPY_PY_BUILTINS_STR_SPLITLINES (1)
#define MICROPY_PY_BUILTINS_BYTEARRAY (1)
#define MICROPY_PY_BUILTINS_MEMORYVIEW (1)
#define MICROPY_PY_BUILTINS_SET (1)
#define MICROPY_PY_BUILTINS_SLICE (1)
#define MICROPY_PY_BUILTINS_SLICE_ATTRS (1)
#define MICROPY_PY_BUILTINS_SLICE_INDICES (1)
#define MICROPY_PY_BUILTINS_FROZENSET (1)
#define MICROPY_PY_BUILTINS_PROPERTY (1)
#define MICROPY_PY_BUILTINS_RANGE_ATTRS (1)
#define MICROPY_PY_BUILTINS_ROUND_INT (1)
#define MICROPY_PY_ALL_SPECIAL_METHODS (1)
#define MICROPY_PY_ALL_INPLACE_SPECIAL_METHODS (1)
#define MICROPY_PY_REVERSE_SPECIAL_METHODS (1)
#define MICROPY_PY_BUILTINS_COMPILE (1)
#define MICROPY_PY_BUILTINS_ENUMERATE (1)
#define MICROPY_PY_BUILTINS_EXECFILE (1)
#define MICROPY_PY_BUILTINS_FILTER (1)
#define MICROPY_PY_BUILTINS_REVERSED (1)
#define MICROPY_PY_BUILTINS_NOTIMPLEMENTED (1)
#define MICROPY_PY_BUILTINS_INPUT (1)
#define MICROPY_PY_BUILTINS_MIN_MAX (1)
#define MICROPY_PY_BUILTINS_POW3 (1)
#define MICROPY_PY_BUILTINS_HELP (1)
#define MICROPY_PY_BUILTINS_HELP_TEXT esp32_help_text
#define MICROPY_PY_BUILTINS_HELP_MODULES (1)
#define MICROPY_PY___FILE__ (1)
#define MICROPY_PY_MICROPYTHON_MEM_INFO (1)
#define MICROPY_PY_ARRAY (1)
#define MICROPY_PY_ARRAY_SLICE_ASSIGN (1)
#define MICROPY_PY_ATTRTUPLE (1)
#define MICROPY_PY_COLLECTIONS (1)
#define MICROPY_PY_COLLECTIONS_DEQUE (1)
#define MICROPY_PY_COLLECTIONS_ORDEREDDICT (1)
#define MICROPY_PY_MATH (1)
#define MICROPY_PY_MATH_SPECIAL_FUNCTIONS (1)
#define MICROPY_PY_MATH_ISCLOSE (1)
#define MICROPY_PY_CMATH (1)
#define MICROPY_PY_GC (1)
#define MICROPY_PY_IO (1)
#define MICROPY_PY_IO_IOBASE (1)
#define MICROPY_PY_IO_FILEIO (1)
#define MICROPY_PY_IO_BYTESIO (1)
#define MICROPY_PY_IO_BUFFEREDWRITER (1)
#define MICROPY_PY_STRUCT (1)
#define MICROPY_PY_SYS (1)
#define MICROPY_PY_SYS_MAXSIZE (1)
#define MICROPY_PY_SYS_MODULES (1)
#define MICROPY_PY_SYS_EXIT (1)
#define MICROPY_PY_SYS_STDFILES (1)
#define MICROPY_PY_SYS_STDIO_BUFFER (1)
#define MICROPY_PY_UERRNO (1)
#define MICROPY_PY_USELECT (1)
#define MICROPY_PY_UTIME_MP_HAL (1)
#define MICROPY_PY_THREAD (1)
#define MICROPY_PY_THREAD_GIL (1)
#define MICROPY_PY_THREAD_GIL_VM_DIVISOR (32)
// extended modules
#ifndef MICROPY_PY_BLUETOOTH
#define MICROPY_PY_BLUETOOTH (1)
#define MICROPY_PY_BLUETOOTH_ENABLE_CENTRAL_MODE (1)
#define MICROPY_BLUETOOTH_NIMBLE (1)
#define MICROPY_BLUETOOTH_NIMBLE_BINDINGS_ONLY (1)
#endif
#define MICROPY_EPOCH_IS_1970 (1)
#define MICROPY_PY_UASYNCIO (1)
#define MICROPY_PY_UCTYPES (1)
#define MICROPY_PY_UZLIB (1)
#define MICROPY_PY_UJSON (1)
#define MICROPY_PY_URE (1)
#define MICROPY_PY_URE_SUB (1)
#define MICROPY_PY_UHEAPQ (1)
#define MICROPY_PY_UTIMEQ (1)
#define MICROPY_PY_UHASHLIB (1)
#define MICROPY_PY_UHASHLIB_SHA1 (1)
#define MICROPY_PY_UHASHLIB_SHA256 (1)
#define MICROPY_PY_UCRYPTOLIB (1)
#define MICROPY_PY_UBINASCII (1)
#define MICROPY_PY_UBINASCII_CRC32 (1)
#define MICROPY_PY_URANDOM (1)
#define MICROPY_PY_URANDOM_EXTRA_FUNCS (1)
#define MICROPY_PY_URANDOM_SEED_INIT_FUNC (esp_random())
#define MICROPY_PY_OS_DUPTERM (1)
#define MICROPY_PY_MACHINE (1)
#define MICROPY_PY_MACHINE_PIN_MAKE_NEW mp_pin_make_new
#define MICROPY_PY_MACHINE_BITSTREAM (1)
#define MICROPY_PY_MACHINE_PULSE (1)
#define MICROPY_PY_MACHINE_I2C (1)
#define MICROPY_PY_MACHINE_SPI (1)
#define MICROPY_PY_MACHINE_SPI_MSB (0)
#define MICROPY_PY_MACHINE_SPI_LSB (1)
#ifndef MICROPY_PY_MACHINE_DAC
#define MICROPY_PY_MACHINE_DAC (1)
#endif
#ifndef MICROPY_PY_MACHINE_I2S
#define MICROPY_PY_MACHINE_I2S (1)
#endif
#ifndef MICROPY_HW_ENABLE_SDCARD
#define MICROPY_HW_ENABLE_SDCARD (1)
#endif
#define MICROPY_HW_SOFTSPI_MIN_DELAY (0)
#define MICROPY_HW_SOFTSPI_MAX_BAUDRATE (ets_get_cpu_frequency() * 1000000 / 200) // roughly
#define MICROPY_PY_USSL (1)
#define MICROPY_SSL_MBEDTLS (1)
#define MICROPY_PY_USSL_FINALISER (1)
#define MICROPY_PY_UWEBSOCKET (1)
#define MICROPY_PY_WEBREPL (1)
#define MICROPY_PY_FRAMEBUF (1)
#define MICROPY_PY_BTREE (1)
#define MICROPY_PY_USOCKET_EVENTS (MICROPY_PY_WEBREPL)
#define MICROPY_PY_BLUETOOTH_RANDOM_ADDR (1)
#define MICROPY_PY_BLUETOOTH_DEFAULT_GAP_NAME ("ESP32")
// fatfs configuration
#define MICROPY_FATFS_ENABLE_LFN (1)
#define MICROPY_FATFS_RPATH (2)
#define MICROPY_FATFS_MAX_SS (4096)
#define MICROPY_FATFS_LFN_CODE_PAGE 437 /* 1=SFN/ANSI 437=LFN/U.S.(OEM) */
#define mp_type_fileio mp_type_vfs_posix_fileio
#define mp_type_textio mp_type_vfs_posix_textio
// use vfs's functions for import stat and builtin open
#define mp_import_stat mp_vfs_import_stat
#define mp_builtin_open mp_vfs_open
#define mp_builtin_open_obj mp_vfs_open_obj
// extra built in names to add to the global namespace
#define MICROPY_PORT_BUILTINS \
{ MP_OBJ_NEW_QSTR(MP_QSTR_input), (mp_obj_t)&mp_builtin_input_obj }, \
{ MP_OBJ_NEW_QSTR(MP_QSTR_open), (mp_obj_t)&mp_builtin_open_obj },
// extra built in modules to add to the list of known ones
extern const struct _mp_obj_module_t esp_module;
extern const struct _mp_obj_module_t esp32_module;
extern const struct _mp_obj_module_t utime_module;
extern const struct _mp_obj_module_t uos_module;
extern const struct _mp_obj_module_t mp_module_usocket;
extern const struct _mp_obj_module_t mp_module_machine;
extern const struct _mp_obj_module_t mp_module_network;
extern const struct _mp_obj_module_t mp_module_onewire;
#define MICROPY_PORT_BUILTIN_MODULES \
{ MP_OBJ_NEW_QSTR(MP_QSTR_esp), (mp_obj_t)&esp_module }, \
{ MP_OBJ_NEW_QSTR(MP_QSTR_esp32), (mp_obj_t)&esp32_module }, \
{ MP_OBJ_NEW_QSTR(MP_QSTR_utime), (mp_obj_t)&utime_module }, \
{ MP_OBJ_NEW_QSTR(MP_QSTR_uos), (mp_obj_t)&uos_module }, \
{ MP_OBJ_NEW_QSTR(MP_QSTR_usocket), (mp_obj_t)&mp_module_usocket }, \
{ MP_OBJ_NEW_QSTR(MP_QSTR_machine), (mp_obj_t)&mp_module_machine }, \
{ MP_OBJ_NEW_QSTR(MP_QSTR_network), (mp_obj_t)&mp_module_network }, \
{ MP_OBJ_NEW_QSTR(MP_QSTR__onewire), (mp_obj_t)&mp_module_onewire }, \
#define MP_STATE_PORT MP_STATE_VM
struct _machine_timer_obj_t;
#if MICROPY_PY_LVGL
#ifndef MICROPY_INCLUDED_PY_MPSTATE_H
#define MICROPY_INCLUDED_PY_MPSTATE_H
#include "misc/lv_gc.h"
#undef MICROPY_INCLUDED_PY_MPSTATE_H
#else
#include "misc/lv_gc.h"
#endif
#else
#define LV_ROOTS
#endif
#if MICROPY_BLUETOOTH_NIMBLE
struct mp_bluetooth_nimble_root_pointers_t;
#define MICROPY_PORT_ROOT_POINTER_BLUETOOTH_NIMBLE \
struct _mp_bluetooth_nimble_root_pointers_t *bluetooth_nimble_root_pointers;
#else
#define MICROPY_PORT_ROOT_POINTER_BLUETOOTH_NIMBLE
#endif
#include "soc/soc_caps.h"
#define MICROPY_PORT_ROOT_POINTERS \
LV_ROOTS \
void *mp_lv_user_data; \
const char *readline_hist[8]; \
mp_obj_t machine_pin_irq_handler[40]; \
struct _machine_timer_obj_t *machine_timer_obj_head; \
struct _machine_i2s_obj_t *machine_i2s_obj[SOC_I2S_NUM]; \
MICROPY_PORT_ROOT_POINTER_BLUETOOTH_NIMBLE
// type definitions for the specific machine
#define MICROPY_MAKE_POINTER_CALLABLE(p) ((void *)((mp_uint_t)(p)))
void *esp_native_code_commit(void *, size_t, void *);
#define MP_PLAT_COMMIT_EXEC(buf, len, reloc) esp_native_code_commit(buf, len, reloc)
#define MP_SSIZE_MAX (0x7fffffff)
// Note: these "critical nested" macros do not ensure cross-CPU exclusion,
// the only disable interrupts on the current CPU. To full manage exclusion
// one should use portENTER_CRITICAL/portEXIT_CRITICAL instead.
#include "freertos/FreeRTOS.h"
#define MICROPY_BEGIN_ATOMIC_SECTION() portENTER_CRITICAL_NESTED()
#define MICROPY_END_ATOMIC_SECTION(state) portEXIT_CRITICAL_NESTED(state)
#if MICROPY_PY_USOCKET_EVENTS
#define MICROPY_PY_USOCKET_EVENTS_HANDLER \
extern void usocket_events_handler(void); \
usocket_events_handler();
#else
#define MICROPY_PY_USOCKET_EVENTS_HANDLER
#endif
#if MICROPY_PY_THREAD
#define MICROPY_EVENT_POLL_HOOK \
do { \
extern void mp_handle_pending(bool); \
mp_handle_pending(true); \
MICROPY_PY_USOCKET_EVENTS_HANDLER \
MP_THREAD_GIL_EXIT(); \
MP_THREAD_GIL_ENTER(); \
} while (0);
#else
#define MICROPY_EVENT_POLL_HOOK \
do { \
extern void mp_handle_pending(bool); \
mp_handle_pending(true); \
MICROPY_PY_USOCKET_EVENTS_HANDLER \
asm ("waiti 0"); \
} while (0);
#endif
// Functions that should go in IRAM
#define MICROPY_WRAP_MP_SCHED_EXCEPTION(f) IRAM_ATTR f
#define MICROPY_WRAP_MP_SCHED_KEYBOARD_INTERRUPT(f) IRAM_ATTR f
#define UINT_FMT "%u"
#define INT_FMT "%d"
typedef int32_t mp_int_t; // must be pointer size
typedef uint32_t mp_uint_t; // must be pointer size
typedef long mp_off_t;
// ssize_t, off_t as required by POSIX-signatured functions in stream.h
#include <sys/types.h>
// board specifics
#define MICROPY_PY_SYS_PLATFORM "esp32"
#define MICROPY_PY_SYS_NODE "V3.3"
#ifndef MICROPY_HW_ENABLE_MDNS_QUERIES
#define MICROPY_HW_ENABLE_MDNS_QUERIES (1)
#endif
#ifndef MICROPY_HW_ENABLE_MDNS_RESPONDER
#define MICROPY_HW_ENABLE_MDNS_RESPONDER (1)
#endif
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/mpconfigport.h | C | apache-2.0 | 13,262 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* Development of the code in this file was sponsored by Microbric Pty Ltd
*
* The MIT License (MIT)
*
* Copyright (c) 2014 Damien P. George
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <stdio.h>
#include <string.h>
#include <sys/time.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#if CONFIG_IDF_TARGET_ESP32
#include "esp32/rom/uart.h"
#elif CONFIG_IDF_TARGET_ESP32C3
#include "esp32c3/rom/uart.h"
#elif CONFIG_IDF_TARGET_ESP32S2
#include "esp32s2/rom/uart.h"
#elif CONFIG_IDF_TARGET_ESP32S3
#include "esp32s3/rom/uart.h"
#endif
#include "py/obj.h"
#include "py/objstr.h"
#include "py/stream.h"
#include "py/mpstate.h"
#include "py/mphal.h"
#include "extmod/misc.h"
#include "shared/timeutils/timeutils.h"
#include "shared/runtime/pyexec.h"
#include "mphalport.h"
#include "usb.h"
#include "usb_serial_jtag.h"
TaskHandle_t mp_main_task_handle;
STATIC uint8_t stdin_ringbuf_array[260];
ringbuf_t stdin_ringbuf = {stdin_ringbuf_array, sizeof(stdin_ringbuf_array), 0, 0};
// Check the ESP-IDF error code and raise an OSError if it's not ESP_OK.
void check_esp_err(esp_err_t code) {
if (code != ESP_OK) {
// map esp-idf error code to posix error code
uint32_t pcode = -code;
switch (code) {
case ESP_ERR_NO_MEM:
pcode = MP_ENOMEM;
break;
case ESP_ERR_TIMEOUT:
pcode = MP_ETIMEDOUT;
break;
case ESP_ERR_NOT_SUPPORTED:
pcode = MP_EOPNOTSUPP;
break;
}
// construct string object
mp_obj_str_t *o_str = m_new_obj_maybe(mp_obj_str_t);
if (o_str == NULL) {
mp_raise_OSError(pcode);
return;
}
o_str->base.type = &mp_type_str;
o_str->data = (const byte *)esp_err_to_name(code); // esp_err_to_name ret's ptr to const str
o_str->len = strlen((char *)o_str->data);
o_str->hash = qstr_compute_hash(o_str->data, o_str->len);
// raise
mp_obj_t args[2] = { MP_OBJ_NEW_SMALL_INT(pcode), MP_OBJ_FROM_PTR(o_str)};
nlr_raise(mp_obj_exception_make_new(&mp_type_OSError, 2, 0, args));
}
}
uintptr_t mp_hal_stdio_poll(uintptr_t poll_flags) {
uintptr_t ret = 0;
if ((poll_flags & MP_STREAM_POLL_RD) && stdin_ringbuf.iget != stdin_ringbuf.iput) {
ret |= MP_STREAM_POLL_RD;
}
return ret;
}
int mp_hal_stdin_rx_chr(void) {
for (;;) {
int c = ringbuf_get(&stdin_ringbuf);
if (c != -1) {
return c;
}
MICROPY_EVENT_POLL_HOOK
ulTaskNotifyTake(pdFALSE, 1);
}
}
void mp_hal_stdout_tx_strn(const char *str, size_t len) {
// Only release the GIL if many characters are being sent
bool release_gil = len > 20;
if (release_gil) {
MP_THREAD_GIL_EXIT();
}
#if CONFIG_USB_ENABLED
usb_tx_strn(str, len);
#elif CONFIG_ESP_CONSOLE_USB_SERIAL_JTAG
usb_serial_jtag_tx_strn(str, len);
#else
for (uint32_t i = 0; i < len; ++i) {
uart_tx_one_char(str[i]);
}
#endif
if (release_gil) {
MP_THREAD_GIL_ENTER();
}
#if MICROPY_PY_OS_DUPTERM
mp_uos_dupterm_tx_strn(str, len);
#endif
}
uint32_t mp_hal_ticks_ms(void) {
return esp_timer_get_time() / 1000;
}
uint32_t mp_hal_ticks_us(void) {
return esp_timer_get_time();
}
void mp_hal_delay_ms(uint32_t ms) {
uint64_t us = ms * 1000;
uint64_t dt;
uint64_t t0 = esp_timer_get_time();
for (;;) {
mp_handle_pending(true);
MICROPY_PY_USOCKET_EVENTS_HANDLER
MP_THREAD_GIL_EXIT();
uint64_t t1 = esp_timer_get_time();
dt = t1 - t0;
if (dt + portTICK_PERIOD_MS * 1000 >= us) {
// doing a vTaskDelay would take us beyond requested delay time
taskYIELD();
MP_THREAD_GIL_ENTER();
t1 = esp_timer_get_time();
dt = t1 - t0;
break;
} else {
ulTaskNotifyTake(pdFALSE, 1);
MP_THREAD_GIL_ENTER();
}
}
if (dt < us) {
// do the remaining delay accurately
mp_hal_delay_us(us - dt);
}
}
void mp_hal_delay_us(uint32_t us) {
// these constants are tested for a 240MHz clock
const uint32_t this_overhead = 5;
const uint32_t pend_overhead = 150;
// return if requested delay is less than calling overhead
if (us < this_overhead) {
return;
}
us -= this_overhead;
uint64_t t0 = esp_timer_get_time();
for (;;) {
uint64_t dt = esp_timer_get_time() - t0;
if (dt >= us) {
return;
}
if (dt + pend_overhead < us) {
// we have enough time to service pending events
// (don't use MICROPY_EVENT_POLL_HOOK because it also yields)
mp_handle_pending(true);
}
}
}
uint64_t mp_hal_time_ns(void) {
struct timeval tv;
gettimeofday(&tv, NULL);
uint64_t ns = tv.tv_sec * 1000000000ULL;
ns += (uint64_t)tv.tv_usec * 1000ULL;
return ns;
}
// Wake up the main task if it is sleeping
void mp_hal_wake_main_task_from_isr(void) {
BaseType_t xHigherPriorityTaskWoken = pdFALSE;
vTaskNotifyGiveFromISR(mp_main_task_handle, &xHigherPriorityTaskWoken);
if (xHigherPriorityTaskWoken == pdTRUE) {
portYIELD_FROM_ISR();
}
}
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/mphalport.c | C | apache-2.0 | 6,457 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* Development of the code in this file was sponsored by Microbric Pty Ltd
*
* The MIT License (MIT)
*
* Copyright (c) 2014 Damien P. George
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#ifndef INCLUDED_MPHALPORT_H
#define INCLUDED_MPHALPORT_H
#include "py/ringbuf.h"
#include "shared/runtime/interrupt_char.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
// The core that the MicroPython task(s) are pinned to.
// Until we move to IDF 4.2+, we need NimBLE on core 0, and for synchronisation
// with the ringbuffer and scheduler MP needs to be on the same core.
// See https://github.com/micropython/micropython/issues/5489
#define MP_TASK_COREID (0)
extern TaskHandle_t mp_main_task_handle;
extern ringbuf_t stdin_ringbuf;
// Check the ESP-IDF error code and raise an OSError if it's not ESP_OK.
void check_esp_err(esp_err_t code);
uint32_t mp_hal_ticks_us(void);
__attribute__((always_inline)) static inline uint32_t mp_hal_ticks_cpu(void) {
uint32_t ccount;
#if CONFIG_IDF_TARGET_ESP32C3
__asm__ __volatile__ ("csrr %0, 0x7E2" : "=r" (ccount)); // Machine Performance Counter Value
#else
__asm__ __volatile__ ("rsr %0,ccount" : "=a" (ccount));
#endif
return ccount;
}
// This macro is used to implement PEP 475 to retry specified syscalls on EINTR
#define MP_HAL_RETRY_SYSCALL(ret, syscall, raise) \
{ \
for (;;) { \
MP_THREAD_GIL_EXIT(); \
ret = syscall; \
MP_THREAD_GIL_ENTER(); \
if (ret == -1) { \
int err = errno; \
if (err == MP_EINTR) { \
mp_handle_pending(true); \
continue; \
} \
raise; \
} \
break; \
} \
}
void mp_hal_delay_us(uint32_t);
#define mp_hal_delay_us_fast(us) ets_delay_us(us)
void mp_hal_set_interrupt_char(int c);
uint32_t mp_hal_get_cpu_freq(void);
#define mp_hal_quiet_timing_enter() MICROPY_BEGIN_ATOMIC_SECTION()
#define mp_hal_quiet_timing_exit(irq_state) MICROPY_END_ATOMIC_SECTION(irq_state)
// Wake up the main task if it is sleeping
void mp_hal_wake_main_task_from_isr(void);
// C-level pin HAL
#include "py/obj.h"
#include "driver/gpio.h"
#define MP_HAL_PIN_FMT "%u"
#define mp_hal_pin_obj_t gpio_num_t
mp_hal_pin_obj_t machine_pin_get_id(mp_obj_t pin_in);
#define mp_hal_get_pin_obj(o) machine_pin_get_id(o)
#define mp_obj_get_pin(o) machine_pin_get_id(o) // legacy name; only to support esp8266/modonewire
#define mp_hal_pin_name(p) (p)
static inline void mp_hal_pin_input(mp_hal_pin_obj_t pin) {
gpio_pad_select_gpio(pin);
gpio_set_direction(pin, GPIO_MODE_INPUT);
}
static inline void mp_hal_pin_output(mp_hal_pin_obj_t pin) {
gpio_pad_select_gpio(pin);
gpio_set_direction(pin, GPIO_MODE_INPUT_OUTPUT);
}
static inline void mp_hal_pin_open_drain(mp_hal_pin_obj_t pin) {
gpio_pad_select_gpio(pin);
gpio_set_direction(pin, GPIO_MODE_INPUT_OUTPUT_OD);
}
static inline void mp_hal_pin_od_low(mp_hal_pin_obj_t pin) {
gpio_set_level(pin, 0);
}
static inline void mp_hal_pin_od_high(mp_hal_pin_obj_t pin) {
gpio_set_level(pin, 1);
}
static inline int mp_hal_pin_read(mp_hal_pin_obj_t pin) {
return gpio_get_level(pin);
}
static inline void mp_hal_pin_write(mp_hal_pin_obj_t pin, int v) {
gpio_set_level(pin, v);
}
#endif // INCLUDED_MPHALPORT_H
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/mphalport.h | C | apache-2.0 | 4,860 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2019 Jim Mussared
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include "py/runtime.h"
#include "py/mperrno.h"
#include "py/mphal.h"
#if MICROPY_PY_BLUETOOTH && MICROPY_BLUETOOTH_NIMBLE
#define DEBUG_printf(...) // printf("nimble (esp32): " __VA_ARGS__)
#include "esp_nimble_hci.h"
#include "nimble/nimble_port.h"
#include "nimble/nimble_port_freertos.h"
#include "extmod/nimble/modbluetooth_nimble.h"
STATIC void ble_host_task(void *param) {
DEBUG_printf("ble_host_task\n");
nimble_port_run(); // This function will return only when nimble_port_stop() is executed.
nimble_port_freertos_deinit();
}
void mp_bluetooth_nimble_port_hci_init(void) {
DEBUG_printf("mp_bluetooth_nimble_port_hci_init\n");
esp_nimble_hci_and_controller_init();
}
void mp_bluetooth_nimble_port_hci_deinit(void) {
DEBUG_printf("mp_bluetooth_nimble_port_hci_deinit\n");
esp_nimble_hci_and_controller_deinit();
}
void mp_bluetooth_nimble_port_start(void) {
DEBUG_printf("mp_bluetooth_nimble_port_start\n");
nimble_port_freertos_init(ble_host_task);
}
void mp_bluetooth_nimble_port_shutdown(void) {
DEBUG_printf("mp_bluetooth_nimble_port_shutdown\n");
// Despite the name, these is an ESP32-specific (no other NimBLE ports have these functions).
// Calls ble_hs_stop() and waits for stack shutdown.
nimble_port_stop();
// Shuts down the event queue.
nimble_port_deinit();
// Mark stack as shutdown.
mp_bluetooth_nimble_ble_state = MP_BLUETOOTH_NIMBLE_BLE_STATE_OFF;
}
#endif
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/mpnimbleport.c | C | apache-2.0 | 2,687 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2016 Damien P. George on behalf of Pycom Ltd
* Copyright (c) 2017 Pycom Limited
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include "stdio.h"
#include "py/runtime.h"
#include "py/gc.h"
#include "py/mpthread.h"
#include "py/mphal.h"
#include "mpthreadport.h"
#include "esp_task.h"
#if MICROPY_PY_THREAD
#define MP_THREAD_MIN_STACK_SIZE (4 * 1024)
#define MP_THREAD_DEFAULT_STACK_SIZE (MP_THREAD_MIN_STACK_SIZE + 1024)
#define MP_THREAD_PRIORITY (ESP_TASK_PRIO_MIN + 1)
// this structure forms a linked list, one node per active thread
typedef struct _thread_t {
TaskHandle_t id; // system id of thread
int ready; // whether the thread is ready and running
void *arg; // thread Python args, a GC root pointer
void *stack; // pointer to the stack
size_t stack_len; // number of words in the stack
struct _thread_t *next;
} thread_t;
// the mutex controls access to the linked list
STATIC mp_thread_mutex_t thread_mutex;
STATIC thread_t thread_entry0;
STATIC thread_t *thread = NULL; // root pointer, handled by mp_thread_gc_others
void mp_thread_init(void *stack, uint32_t stack_len) {
mp_thread_set_state(&mp_state_ctx.thread);
// create the first entry in the linked list of all threads
thread = &thread_entry0;
thread->id = xTaskGetCurrentTaskHandle();
thread->ready = 1;
thread->arg = NULL;
thread->stack = stack;
thread->stack_len = stack_len;
thread->next = NULL;
mp_thread_mutex_init(&thread_mutex);
}
void mp_thread_gc_others(void) {
mp_thread_mutex_lock(&thread_mutex, 1);
for (thread_t *th = thread; th != NULL; th = th->next) {
gc_collect_root((void **)&th, 1);
gc_collect_root(&th->arg, 1); // probably not needed
if (th->id == xTaskGetCurrentTaskHandle()) {
continue;
}
if (!th->ready) {
continue;
}
gc_collect_root(th->stack, th->stack_len);
}
mp_thread_mutex_unlock(&thread_mutex);
}
mp_state_thread_t *mp_thread_get_state(void) {
mp_state_thread_t *state = (mp_state_thread_t *)pvTaskGetThreadLocalStoragePointer(NULL, 1);
if (state == NULL) {
state = (mp_state_thread_t *)pvTaskGetThreadLocalStoragePointer(mp_main_task_handle, 1);
}
return state;
}
void mp_thread_set_state(mp_state_thread_t *state) {
vTaskSetThreadLocalStoragePointer(NULL, 1, state);
}
void mp_thread_start(void) {
mp_thread_mutex_lock(&thread_mutex, 1);
for (thread_t *th = thread; th != NULL; th = th->next) {
if (th->id == xTaskGetCurrentTaskHandle()) {
th->ready = 1;
break;
}
}
mp_thread_mutex_unlock(&thread_mutex);
}
STATIC void *(*ext_thread_entry)(void *) = NULL;
STATIC void freertos_entry(void *arg) {
if (ext_thread_entry) {
ext_thread_entry(arg);
}
vTaskDelete(NULL);
for (;;) {;
}
}
void mp_thread_create_ex(void *(*entry)(void *), void *arg, size_t *stack_size, int priority, char *name) {
// store thread entry function into a global variable so we can access it
ext_thread_entry = entry;
if (*stack_size == 0) {
*stack_size = MP_THREAD_DEFAULT_STACK_SIZE; // default stack size
} else if (*stack_size < MP_THREAD_MIN_STACK_SIZE) {
*stack_size = MP_THREAD_MIN_STACK_SIZE; // minimum stack size
}
// Allocate linked-list node (must be outside thread_mutex lock)
thread_t *th = m_new_obj(thread_t);
mp_thread_mutex_lock(&thread_mutex, 1);
// create thread
BaseType_t result = xTaskCreatePinnedToCore(freertos_entry, name, *stack_size / sizeof(StackType_t), arg, priority, &th->id, MP_TASK_COREID);
if (result != pdPASS) {
mp_thread_mutex_unlock(&thread_mutex);
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("can't create thread"));
}
// add thread to linked list of all threads
th->ready = 0;
th->arg = arg;
th->stack = pxTaskGetStackStart(th->id);
th->stack_len = *stack_size / sizeof(uintptr_t);
th->next = thread;
thread = th;
// adjust the stack_size to provide room to recover from hitting the limit
*stack_size -= 1024;
mp_thread_mutex_unlock(&thread_mutex);
}
void mp_thread_create(void *(*entry)(void *), void *arg, size_t *stack_size) {
mp_thread_create_ex(entry, arg, stack_size, MP_THREAD_PRIORITY, "mp_thread");
}
void mp_thread_finish(void) {
mp_thread_mutex_lock(&thread_mutex, 1);
for (thread_t *th = thread; th != NULL; th = th->next) {
if (th->id == xTaskGetCurrentTaskHandle()) {
th->ready = 0;
break;
}
}
mp_thread_mutex_unlock(&thread_mutex);
}
// This is called from the FreeRTOS idle task and is not within Python context,
// so MP_STATE_THREAD is not valid and it does not have the GIL.
void vPortCleanUpTCB(void *tcb) {
if (thread == NULL) {
// threading not yet initialised
return;
}
thread_t *prev = NULL;
mp_thread_mutex_lock(&thread_mutex, 1);
for (thread_t *th = thread; th != NULL; prev = th, th = th->next) {
// unlink the node from the list
if ((void *)th->id == tcb) {
if (prev != NULL) {
prev->next = th->next;
} else {
// move the start pointer
thread = th->next;
}
// The "th" memory will eventually be reclaimed by the GC.
break;
}
}
mp_thread_mutex_unlock(&thread_mutex);
}
void mp_thread_mutex_init(mp_thread_mutex_t *mutex) {
// Need a binary semaphore so a lock can be acquired on one Python thread
// and then released on another.
mutex->handle = xSemaphoreCreateBinaryStatic(&mutex->buffer);
xSemaphoreGive(mutex->handle);
}
int mp_thread_mutex_lock(mp_thread_mutex_t *mutex, int wait) {
return pdTRUE == xSemaphoreTake(mutex->handle, wait ? portMAX_DELAY : 0);
}
void mp_thread_mutex_unlock(mp_thread_mutex_t *mutex) {
xSemaphoreGive(mutex->handle);
}
void mp_thread_deinit(void) {
for (;;) {
// Find a task to delete
TaskHandle_t id = NULL;
mp_thread_mutex_lock(&thread_mutex, 1);
for (thread_t *th = thread; th != NULL; th = th->next) {
// Don't delete the current task
if (th->id != xTaskGetCurrentTaskHandle()) {
id = th->id;
break;
}
}
mp_thread_mutex_unlock(&thread_mutex);
if (id == NULL) {
// No tasks left to delete
break;
} else {
// Call FreeRTOS to delete the task (it will call vPortCleanUpTCB)
vTaskDelete(id);
}
}
}
#else
void vPortCleanUpTCB(void *tcb) {
}
#endif // MICROPY_PY_THREAD
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/mpthreadport.c | C | apache-2.0 | 8,005 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2016 Damien P. George on behalf of Pycom Ltd
* Copyright (c) 2017 Pycom Limited
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#ifndef MICROPY_INCLUDED_ESP32_MPTHREADPORT_H
#define MICROPY_INCLUDED_ESP32_MPTHREADPORT_H
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/semphr.h"
#include "freertos/queue.h"
typedef struct _mp_thread_mutex_t {
SemaphoreHandle_t handle;
StaticSemaphore_t buffer;
} mp_thread_mutex_t;
void mp_thread_init(void *stack, uint32_t stack_len);
void mp_thread_gc_others(void);
void mp_thread_deinit(void);
#endif // MICROPY_INCLUDED_ESP32_MPTHREADPORT_H
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/mpthreadport.h | C | apache-2.0 | 1,776 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2017 "Eric Poulsen" <eric@zyxod.com>
* Copyright (c) 2021 "Tobias Eydam" <tobiaseydam@hotmail.com>
*
* Based on the ESP IDF example code which is Public Domain / CC0
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include "py/runtime.h"
#include "py/mphal.h"
#include "esp_idf_version.h"
// LAN only for ESP32 (not ESP32S2) and only for ESP-IDF v4.1 and higher
#if (ESP_IDF_VERSION_MAJOR == 4) && (ESP_IDF_VERSION_MINOR >= 1) && (CONFIG_IDF_TARGET_ESP32)
#include "esp_eth.h"
#include "esp_eth_mac.h"
#include "esp_event.h"
#include "esp_log.h"
#include "esp_netif.h"
#include "modnetwork.h"
typedef struct _lan_if_obj_t {
mp_obj_base_t base;
int if_id; // MUST BE FIRST to match wlan_if_obj_t
bool initialized;
bool active;
uint8_t mdc_pin;
uint8_t mdio_pin;
int8_t phy_power_pin;
uint8_t phy_addr;
uint8_t phy_type;
esp_eth_phy_t *phy;
esp_netif_t *eth_netif;
esp_eth_handle_t eth_handle;
} lan_if_obj_t;
const mp_obj_type_t lan_if_type;
STATIC lan_if_obj_t lan_obj = {{&lan_if_type}, ESP_IF_ETH, false, false};
STATIC uint8_t eth_status = 0;
static void eth_event_handler(void *arg, esp_event_base_t event_base,
int32_t event_id, void *event_data) {
switch (event_id) {
case ETHERNET_EVENT_CONNECTED:
eth_status = ETH_CONNECTED;
ESP_LOGI("ethernet", "Ethernet Link Up");
break;
case ETHERNET_EVENT_DISCONNECTED:
eth_status = ETH_DISCONNECTED;
ESP_LOGI("ethernet", "Ethernet Link Down");
break;
case ETHERNET_EVENT_START:
eth_status = ETH_STARTED;
ESP_LOGI("ethernet", "Ethernet Started");
break;
case ETHERNET_EVENT_STOP:
eth_status = ETH_STOPPED;
ESP_LOGI("ethernet", "Ethernet Stopped");
break;
case IP_EVENT_ETH_GOT_IP:
eth_status = ETH_GOT_IP;
ESP_LOGI("ethernet", "Ethernet Got IP");
break;
default:
break;
}
}
STATIC mp_obj_t get_lan(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
lan_if_obj_t *self = &lan_obj;
if (self->initialized) {
return MP_OBJ_FROM_PTR(&lan_obj);
}
enum { ARG_id, ARG_mdc, ARG_mdio, ARG_power, ARG_phy_addr, ARG_phy_type };
static const mp_arg_t allowed_args[] = {
{ MP_QSTR_id, MP_ARG_OBJ, {.u_obj = mp_const_none} },
{ MP_QSTR_mdc, MP_ARG_KW_ONLY | MP_ARG_REQUIRED | MP_ARG_OBJ },
{ MP_QSTR_mdio, MP_ARG_KW_ONLY | MP_ARG_REQUIRED | MP_ARG_OBJ },
{ MP_QSTR_power, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} },
{ MP_QSTR_phy_addr, MP_ARG_KW_ONLY | MP_ARG_REQUIRED | MP_ARG_INT },
{ MP_QSTR_phy_type, MP_ARG_KW_ONLY | MP_ARG_REQUIRED | MP_ARG_INT },
};
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
if (args[ARG_id].u_obj != mp_const_none) {
if (mp_obj_get_int(args[ARG_id].u_obj) != 0) {
mp_raise_ValueError(MP_ERROR_TEXT("invalid LAN interface identifier"));
}
}
self->mdc_pin = machine_pin_get_id(args[ARG_mdc].u_obj);
self->mdio_pin = machine_pin_get_id(args[ARG_mdio].u_obj);
self->phy_power_pin = args[ARG_power].u_obj == mp_const_none ? -1 : machine_pin_get_id(args[ARG_power].u_obj);
if (args[ARG_phy_addr].u_int < 0x00 || args[ARG_phy_addr].u_int > 0x1f) {
mp_raise_ValueError(MP_ERROR_TEXT("invalid phy address"));
}
self->phy_addr = args[ARG_phy_addr].u_int;
if (args[ARG_phy_type].u_int != PHY_LAN8720 &&
args[ARG_phy_type].u_int != PHY_IP101 &&
args[ARG_phy_type].u_int != PHY_RTL8201 &&
#if ESP_IDF_VERSION_MINOR >= 3 // KSZ8041 is new in ESP-IDF v4.3
args[ARG_phy_type].u_int != PHY_KSZ8041 &&
#endif
args[ARG_phy_type].u_int != PHY_DP83848) {
mp_raise_ValueError(MP_ERROR_TEXT("invalid phy type"));
}
eth_mac_config_t mac_config = ETH_MAC_DEFAULT_CONFIG();
mac_config.smi_mdc_gpio_num = self->mdc_pin;
mac_config.smi_mdio_gpio_num = self->mdio_pin;
esp_eth_mac_t *mac = esp_eth_mac_new_esp32(&mac_config);
eth_phy_config_t phy_config = ETH_PHY_DEFAULT_CONFIG();
phy_config.phy_addr = self->phy_addr;
phy_config.reset_gpio_num = self->phy_power_pin;
self->phy = NULL;
switch (args[ARG_phy_type].u_int) {
case PHY_LAN8720:
self->phy = esp_eth_phy_new_lan8720(&phy_config);
break;
case PHY_IP101:
self->phy = esp_eth_phy_new_ip101(&phy_config);
break;
case PHY_RTL8201:
self->phy = esp_eth_phy_new_rtl8201(&phy_config);
break;
case PHY_DP83848:
self->phy = esp_eth_phy_new_dp83848(&phy_config);
break;
case PHY_KSZ8041:
#if ESP_IDF_VERSION_MINOR >= 3 // KSZ8041 is new in ESP-IDF v4.3
self->phy = esp_eth_phy_new_ksz8041(&phy_config);
break;
#endif
default:
mp_raise_ValueError(MP_ERROR_TEXT("unknown phy"));
}
if (esp_netif_init() != ESP_OK) {
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("esp_netif_init failed"));
}
esp_netif_config_t cfg = ESP_NETIF_DEFAULT_ETH();
self->eth_netif = esp_netif_new(&cfg);
if (esp_eth_set_default_handlers(self->eth_netif) != ESP_OK) {
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("esp_eth_set_default_handlers failed (invalid parameter)"));
}
if (esp_event_handler_register(ETH_EVENT, ESP_EVENT_ANY_ID, ð_event_handler, NULL) != ESP_OK) {
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("esp_event_handler_register failed"));
}
if (esp_event_handler_register(IP_EVENT, ESP_EVENT_ANY_ID, ð_event_handler, NULL) != ESP_OK) {
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("esp_event_handler_register failed"));
}
esp_eth_config_t config = ETH_DEFAULT_CONFIG(mac, self->phy);
esp_err_t esp_err = esp_eth_driver_install(&config, &self->eth_handle);
if (esp_err == ESP_OK) {
self->active = false;
self->initialized = true;
} else {
if (esp_err == ESP_ERR_INVALID_ARG) {
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("esp_eth_driver_install failed with invalid argument"));
} else if (esp_err == ESP_ERR_NO_MEM) {
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("esp_eth_driver_install failed with no memory for driver"));
} else {
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("esp_eth_driver_install failed"));
}
}
if (esp_netif_attach(self->eth_netif, esp_eth_new_netif_glue(self->eth_handle)) != ESP_OK) {
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("esp_netif_attach failed"));
}
eth_status = ETH_INITIALIZED;
return MP_OBJ_FROM_PTR(&lan_obj);
}
MP_DEFINE_CONST_FUN_OBJ_KW(get_lan_obj, 0, get_lan);
STATIC mp_obj_t lan_active(size_t n_args, const mp_obj_t *args) {
lan_if_obj_t *self = MP_OBJ_TO_PTR(args[0]);
if (n_args > 1) {
if (mp_obj_is_true(args[1])) {
self->active = (esp_eth_start(self->eth_handle) == ESP_OK);
if (!self->active) {
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("ethernet enable failed"));
}
} else {
self->active = !(esp_eth_stop(self->eth_handle) == ESP_OK);
if (self->active) {
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("ethernet disable failed"));
}
}
}
return mp_obj_new_bool(self->active);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(lan_active_obj, 1, 2, lan_active);
STATIC mp_obj_t lan_status(mp_obj_t self_in) {
return MP_OBJ_NEW_SMALL_INT(eth_status);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(lan_status_obj, lan_status);
STATIC mp_obj_t lan_isconnected(mp_obj_t self_in) {
lan_if_obj_t *self = MP_OBJ_TO_PTR(self_in);
return self->active ? mp_obj_new_bool(self->phy->get_link(self->phy) == ETH_LINK_UP) : mp_const_false;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(lan_isconnected_obj, lan_isconnected);
STATIC mp_obj_t lan_config(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs) {
if (n_args != 1 && kwargs->used != 0) {
mp_raise_TypeError(MP_ERROR_TEXT("either pos or kw args are allowed"));
}
lan_if_obj_t *self = MP_OBJ_TO_PTR(args[0]);
#define QS(x) (uintptr_t)MP_OBJ_NEW_QSTR(x)
if (kwargs->used != 0) {
for (size_t i = 0; i < kwargs->alloc; i++) {
if (mp_map_slot_is_filled(kwargs, i)) {
switch ((uintptr_t)kwargs->table[i].key) {
case QS(MP_QSTR_mac): {
mp_buffer_info_t bufinfo;
mp_get_buffer_raise(kwargs->table[i].value, &bufinfo, MP_BUFFER_READ);
if (bufinfo.len != 6) {
mp_raise_ValueError(MP_ERROR_TEXT("invalid buffer length"));
}
esp_eth_ioctl(self->eth_handle, ETH_CMD_S_MAC_ADDR, bufinfo.buf);
break;
}
default:
break;
}
}
}
return mp_const_none;
}
if (n_args != 2) {
mp_raise_TypeError(MP_ERROR_TEXT("can query only one param"));
}
mp_obj_t val = mp_const_none;
switch ((uintptr_t)args[1]) {
case QS(MP_QSTR_mac): {
uint8_t mac[6];
esp_eth_ioctl(self->eth_handle, ETH_CMD_G_MAC_ADDR, mac);
return mp_obj_new_bytes(mac, sizeof(mac));
}
default:
mp_raise_ValueError(MP_ERROR_TEXT("unknown config param"));
}
return val;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_KW(lan_config_obj, 1, lan_config);
STATIC const mp_rom_map_elem_t lan_if_locals_dict_table[] = {
{ MP_ROM_QSTR(MP_QSTR_active), MP_ROM_PTR(&lan_active_obj) },
{ MP_ROM_QSTR(MP_QSTR_isconnected), MP_ROM_PTR(&lan_isconnected_obj) },
{ MP_ROM_QSTR(MP_QSTR_status), MP_ROM_PTR(&lan_status_obj) },
{ MP_ROM_QSTR(MP_QSTR_config), MP_ROM_PTR(&lan_config_obj) },
{ MP_ROM_QSTR(MP_QSTR_ifconfig), MP_ROM_PTR(&esp_ifconfig_obj) },
};
STATIC MP_DEFINE_CONST_DICT(lan_if_locals_dict, lan_if_locals_dict_table);
const mp_obj_type_t lan_if_type = {
{ &mp_type_type },
.name = MP_QSTR_LAN,
.locals_dict = (mp_obj_dict_t *)&lan_if_locals_dict,
};
#endif
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/network_lan.c | C | apache-2.0 | 11,717 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2018 "Eric Poulsen" <eric@zyxod.com>
*
* Based on the ESP IDF example code which is Public Domain / CC0
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include "py/runtime.h"
#include "py/mphal.h"
#include "py/objtype.h"
#include "py/stream.h"
#include "shared/netutils/netutils.h"
#include "modmachine.h"
#include "netif/ppp/ppp.h"
#include "netif/ppp/pppos.h"
#include "lwip/err.h"
#include "lwip/sockets.h"
#include "lwip/sys.h"
#include "lwip/netdb.h"
#include "lwip/dns.h"
#include "netif/ppp/pppapi.h"
#define PPP_CLOSE_TIMEOUT_MS (4000)
typedef struct _ppp_if_obj_t {
mp_obj_base_t base;
bool active;
bool connected;
volatile bool clean_close;
ppp_pcb *pcb;
mp_obj_t stream;
SemaphoreHandle_t inactiveWaitSem;
volatile TaskHandle_t client_task_handle;
struct netif pppif;
} ppp_if_obj_t;
const mp_obj_type_t ppp_if_type;
static void ppp_status_cb(ppp_pcb *pcb, int err_code, void *ctx) {
ppp_if_obj_t *self = ctx;
struct netif *pppif = ppp_netif(self->pcb);
switch (err_code) {
case PPPERR_NONE:
self->connected = (pppif->ip_addr.u_addr.ip4.addr != 0);
break;
case PPPERR_USER:
self->clean_close = true;
break;
case PPPERR_CONNECT:
self->connected = false;
break;
default:
break;
}
}
STATIC mp_obj_t ppp_make_new(mp_obj_t stream) {
mp_get_stream_raise(stream, MP_STREAM_OP_READ | MP_STREAM_OP_WRITE);
ppp_if_obj_t *self = m_new_obj_with_finaliser(ppp_if_obj_t);
self->base.type = &ppp_if_type;
self->stream = stream;
self->active = false;
self->connected = false;
self->clean_close = false;
self->client_task_handle = NULL;
return MP_OBJ_FROM_PTR(self);
}
MP_DEFINE_CONST_FUN_OBJ_1(ppp_make_new_obj, ppp_make_new);
static u32_t ppp_output_callback(ppp_pcb *pcb, u8_t *data, u32_t len, void *ctx) {
ppp_if_obj_t *self = ctx;
int err;
return mp_stream_rw(self->stream, data, len, &err, MP_STREAM_RW_WRITE);
}
static void pppos_client_task(void *self_in) {
ppp_if_obj_t *self = (ppp_if_obj_t *)self_in;
uint8_t buf[256];
while (ulTaskNotifyTake(pdTRUE, 0) == 0) {
int err;
int len = mp_stream_rw(self->stream, buf, sizeof(buf), &err, 0);
if (len > 0) {
pppos_input_tcpip(self->pcb, (u8_t *)buf, len);
}
}
self->client_task_handle = NULL;
vTaskDelete(NULL);
}
STATIC mp_obj_t ppp_active(size_t n_args, const mp_obj_t *args) {
ppp_if_obj_t *self = MP_OBJ_TO_PTR(args[0]);
if (n_args > 1) {
if (mp_obj_is_true(args[1])) {
if (self->active) {
return mp_const_true;
}
self->pcb = pppapi_pppos_create(&self->pppif, ppp_output_callback, ppp_status_cb, self);
if (self->pcb == NULL) {
mp_raise_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("init failed"));
}
self->active = true;
} else {
if (!self->active) {
return mp_const_false;
}
if (self->client_task_handle != NULL) { // is connecting or connected?
// Wait for PPPERR_USER, with timeout
pppapi_close(self->pcb, 0);
uint32_t t0 = mp_hal_ticks_ms();
while (!self->clean_close && mp_hal_ticks_ms() - t0 < PPP_CLOSE_TIMEOUT_MS) {
mp_hal_delay_ms(10);
}
// Shutdown task
xTaskNotifyGive(self->client_task_handle);
t0 = mp_hal_ticks_ms();
while (self->client_task_handle != NULL && mp_hal_ticks_ms() - t0 < PPP_CLOSE_TIMEOUT_MS) {
mp_hal_delay_ms(10);
}
}
// Release PPP
pppapi_free(self->pcb);
self->pcb = NULL;
self->active = false;
self->connected = false;
self->clean_close = false;
}
}
return mp_obj_new_bool(self->active);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(ppp_active_obj, 1, 2, ppp_active);
STATIC mp_obj_t ppp_connect_py(size_t n_args, const mp_obj_t *args, mp_map_t *kw_args) {
enum { ARG_authmode, ARG_username, ARG_password };
static const mp_arg_t allowed_args[] = {
{ MP_QSTR_authmode, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = PPPAUTHTYPE_NONE} },
{ MP_QSTR_username, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
{ MP_QSTR_password, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
};
mp_arg_val_t parsed_args[MP_ARRAY_SIZE(allowed_args)];
mp_arg_parse_all(n_args - 1, args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, parsed_args);
ppp_if_obj_t *self = MP_OBJ_TO_PTR(args[0]);
if (!self->active) {
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("must be active"));
}
if (self->client_task_handle != NULL) {
mp_raise_OSError(MP_EALREADY);
}
switch (parsed_args[ARG_authmode].u_int) {
case PPPAUTHTYPE_NONE:
case PPPAUTHTYPE_PAP:
case PPPAUTHTYPE_CHAP:
break;
default:
mp_raise_ValueError(MP_ERROR_TEXT("invalid auth"));
}
if (parsed_args[ARG_authmode].u_int != PPPAUTHTYPE_NONE) {
const char *username_str = mp_obj_str_get_str(parsed_args[ARG_username].u_obj);
const char *password_str = mp_obj_str_get_str(parsed_args[ARG_password].u_obj);
pppapi_set_auth(self->pcb, parsed_args[ARG_authmode].u_int, username_str, password_str);
}
if (pppapi_set_default(self->pcb) != ESP_OK) {
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("set default failed"));
}
ppp_set_usepeerdns(self->pcb, true);
if (pppapi_connect(self->pcb, 0) != ESP_OK) {
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("connect failed"));
}
if (xTaskCreatePinnedToCore(pppos_client_task, "ppp", 2048, self, 1, (TaskHandle_t *)&self->client_task_handle, MP_TASK_COREID) != pdPASS) {
mp_raise_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("failed to create worker task"));
}
return mp_const_none;
}
MP_DEFINE_CONST_FUN_OBJ_KW(ppp_connect_obj, 1, ppp_connect_py);
STATIC mp_obj_t ppp_delete(mp_obj_t self_in) {
ppp_if_obj_t *self = MP_OBJ_TO_PTR(self_in);
mp_obj_t args[] = {self, mp_const_false};
ppp_active(2, args);
return mp_const_none;
}
MP_DEFINE_CONST_FUN_OBJ_1(ppp_delete_obj, ppp_delete);
STATIC mp_obj_t ppp_ifconfig(size_t n_args, const mp_obj_t *args) {
ppp_if_obj_t *self = MP_OBJ_TO_PTR(args[0]);
if (n_args == 1) {
// get
const ip_addr_t *dns;
if (self->pcb != NULL) {
dns = dns_getserver(0);
struct netif *pppif = ppp_netif(self->pcb);
mp_obj_t tuple[4] = {
netutils_format_ipv4_addr((uint8_t *)&pppif->ip_addr, NETUTILS_BIG),
netutils_format_ipv4_addr((uint8_t *)&pppif->gw, NETUTILS_BIG),
netutils_format_ipv4_addr((uint8_t *)&pppif->netmask, NETUTILS_BIG),
netutils_format_ipv4_addr((uint8_t *)dns, NETUTILS_BIG),
};
return mp_obj_new_tuple(4, tuple);
} else {
mp_obj_t tuple[4] = { mp_const_none, mp_const_none, mp_const_none, mp_const_none };
return mp_obj_new_tuple(4, tuple);
}
} else {
ip_addr_t dns;
mp_obj_t *items;
mp_obj_get_array_fixed_n(args[1], 4, &items);
netutils_parse_ipv4_addr(items[3], (uint8_t *)&dns.u_addr.ip4, NETUTILS_BIG);
dns_setserver(0, &dns);
return mp_const_none;
}
}
MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(ppp_ifconfig_obj, 1, 2, ppp_ifconfig);
STATIC mp_obj_t ppp_status(mp_obj_t self_in) {
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(ppp_status_obj, ppp_status);
STATIC mp_obj_t ppp_isconnected(mp_obj_t self_in) {
ppp_if_obj_t *self = MP_OBJ_TO_PTR(self_in);
return mp_obj_new_bool(self->connected);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(ppp_isconnected_obj, ppp_isconnected);
STATIC const mp_rom_map_elem_t ppp_if_locals_dict_table[] = {
{ MP_ROM_QSTR(MP_QSTR_active), MP_ROM_PTR(&ppp_active_obj) },
{ MP_ROM_QSTR(MP_QSTR_connect), MP_ROM_PTR(&ppp_connect_obj) },
{ MP_ROM_QSTR(MP_QSTR_isconnected), MP_ROM_PTR(&ppp_isconnected_obj) },
{ MP_ROM_QSTR(MP_QSTR_status), MP_ROM_PTR(&ppp_status_obj) },
{ MP_ROM_QSTR(MP_QSTR_ifconfig), MP_ROM_PTR(&ppp_ifconfig_obj) },
{ MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&ppp_delete_obj) },
{ MP_ROM_QSTR(MP_QSTR_AUTH_NONE), MP_ROM_INT(PPPAUTHTYPE_NONE) },
{ MP_ROM_QSTR(MP_QSTR_AUTH_PAP), MP_ROM_INT(PPPAUTHTYPE_PAP) },
{ MP_ROM_QSTR(MP_QSTR_AUTH_CHAP), MP_ROM_INT(PPPAUTHTYPE_CHAP) },
};
STATIC MP_DEFINE_CONST_DICT(ppp_if_locals_dict, ppp_if_locals_dict_table);
const mp_obj_type_t ppp_if_type = {
{ &mp_type_type },
.name = MP_QSTR_PPP,
.locals_dict = (mp_obj_dict_t *)&ppp_if_locals_dict,
};
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/network_ppp.c | C | apache-2.0 | 10,163 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2014 Damien P. George
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
// qstrs specific to this port, only needed if they aren't auto-generated
// *FORMAT-OFF*
// Entries for sys.path
Q(/lib)
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/qstrdefsport.h | C | apache-2.0 | 1,349 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* Development of the code in this file was sponsored by Microbric Pty Ltd
*
* The MIT License (MIT)
*
* Copyright (c) 2016 Damien P. George
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <stdio.h>
#include "driver/uart.h"
#include "soc/uart_periph.h"
#include "py/runtime.h"
#include "py/mphal.h"
#include "uart.h"
STATIC void uart_irq_handler(void *arg);
void uart_init(void) {
uart_config_t uartcfg = {
.baud_rate = MICROPY_HW_UART_REPL_BAUD,
.data_bits = UART_DATA_8_BITS,
.parity = UART_PARITY_DISABLE,
.stop_bits = UART_STOP_BITS_1,
.flow_ctrl = UART_HW_FLOWCTRL_DISABLE,
.rx_flow_ctrl_thresh = 0
};
uart_param_config(MICROPY_HW_UART_REPL, &uartcfg);
const uint32_t rxbuf = 129; // IDF requires > 128 min
const uint32_t txbuf = 0;
uart_driver_install(MICROPY_HW_UART_REPL, rxbuf, txbuf, 0, NULL, 0);
uart_isr_handle_t handle;
uart_isr_free(MICROPY_HW_UART_REPL);
uart_isr_register(MICROPY_HW_UART_REPL, uart_irq_handler, NULL, ESP_INTR_FLAG_LOWMED | ESP_INTR_FLAG_IRAM, &handle);
uart_enable_rx_intr(MICROPY_HW_UART_REPL);
}
int uart_stdout_tx_strn(const char *str, size_t len) {
size_t remaining = len;
// TODO add a timeout
for (;;) {
int ret = uart_tx_chars(MICROPY_HW_UART_REPL, str, remaining);
if (ret == -1) {
return -1;
}
remaining -= ret;
if (remaining <= 0) {
break;
}
str += ret;
ulTaskNotifyTake(pdFALSE, 1);
}
return len - remaining;
}
// all code executed in ISR must be in IRAM, and any const data must be in DRAM
STATIC void IRAM_ATTR uart_irq_handler(void *arg) {
volatile uart_dev_t *uart = &UART0;
#if CONFIG_IDF_TARGET_ESP32S3
uart->int_clr.rxfifo_full_int_clr = 1;
uart->int_clr.rxfifo_tout_int_clr = 1;
#else
uart->int_clr.rxfifo_full = 1;
uart->int_clr.rxfifo_tout = 1;
uart->int_clr.frm_err = 1;
#endif
while (uart->status.rxfifo_cnt) {
#if CONFIG_IDF_TARGET_ESP32
uint8_t c = uart->fifo.rw_byte;
#elif CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3
uint8_t c = READ_PERI_REG(UART_FIFO_AHB_REG(0)); // UART0
#endif
if (c == mp_interrupt_char) {
mp_sched_keyboard_interrupt();
} else {
// this is an inline function so will be in IRAM
ringbuf_put(&stdin_ringbuf, c);
}
}
}
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/uart.c | C | apache-2.0 | 3,613 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* Development of the code in this file was sponsored by Microbric Pty Ltd
*
* The MIT License (MIT)
*
* Copyright (c) 2016 Damien P. George
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#ifndef MICROPY_INCLUDED_ESP32_UART_H
#define MICROPY_INCLUDED_ESP32_UART_H
#ifndef MICROPY_HW_UART_REPL
#define MICROPY_HW_UART_REPL (UART_NUM_0)
#endif
#ifndef MICROPY_HW_UART_REPL_BAUD
#define MICROPY_HW_UART_REPL_BAUD (115200)
#endif
void uart_init(void);
int uart_stdout_tx_strn(const char *str, size_t len);
#endif // MICROPY_INCLUDED_ESP32_UART_H
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/uart.h | C | apache-2.0 | 1,661 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2021 Damien P. George
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include "py/runtime.h"
#include "py/mphal.h"
#include "usb.h"
#if CONFIG_USB_ENABLED
#include "tinyusb.h"
#include "tusb_cdc_acm.h"
#define CDC_ITF TINYUSB_CDC_ACM_0
static uint8_t usb_rx_buf[CONFIG_USB_CDC_RX_BUFSIZE];
static void usb_callback_rx(int itf, cdcacm_event_t *event) {
// TODO: what happens if more chars come in during this function, are they lost?
for (;;) {
size_t len = 0;
esp_err_t ret = tinyusb_cdcacm_read(itf, usb_rx_buf, sizeof(usb_rx_buf), &len);
if (ret != ESP_OK) {
break;
}
if (len == 0) {
break;
}
for (size_t i = 0; i < len; ++i) {
if (usb_rx_buf[i] == mp_interrupt_char) {
mp_sched_keyboard_interrupt();
} else {
ringbuf_put(&stdin_ringbuf, usb_rx_buf[i]);
}
}
}
}
void usb_init(void) {
// Initialise the USB with defaults.
tinyusb_config_t tusb_cfg = {0};
ESP_ERROR_CHECK(tinyusb_driver_install(&tusb_cfg));
// Initialise the USB serial interface.
tinyusb_config_cdcacm_t amc_cfg = {
.usb_dev = TINYUSB_USBDEV_0,
.cdc_port = CDC_ITF,
.rx_unread_buf_sz = 256,
.callback_rx = &usb_callback_rx,
.callback_rx_wanted_char = NULL,
.callback_line_state_changed = NULL,
.callback_line_coding_changed = NULL
};
ESP_ERROR_CHECK(tusb_cdc_acm_init(&amc_cfg));
}
void usb_tx_strn(const char *str, size_t len) {
while (len) {
size_t l = len;
if (l > CONFIG_USB_CDC_TX_BUFSIZE) {
l = CONFIG_USB_CDC_TX_BUFSIZE;
}
tinyusb_cdcacm_write_queue(CDC_ITF, (uint8_t *)str, l);
tinyusb_cdcacm_write_flush(CDC_ITF, pdMS_TO_TICKS(1000));
str += l;
len -= l;
}
}
#endif // CONFIG_USB_ENABLED
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/usb.c | C | apache-2.0 | 3,059 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2021 Damien P. George
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#ifndef MICROPY_INCLUDED_ESP32_USB_H
#define MICROPY_INCLUDED_ESP32_USB_H
void usb_init(void);
void usb_tx_strn(const char *str, size_t len);
#endif // MICROPY_INCLUDED_ESP32_USB_H
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/usb.h | C | apache-2.0 | 1,408 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2021 Patrick Van Oosterwijck
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include "py/runtime.h"
#include "py/mphal.h"
#include "usb_serial_jtag.h"
#if CONFIG_ESP_CONSOLE_USB_SERIAL_JTAG
#include "hal/usb_serial_jtag_ll.h"
#include "esp_intr_alloc.h"
#include "soc/periph_defs.h"
#define USB_SERIAL_JTAG_BUF_SIZE (64)
static uint8_t rx_buf[USB_SERIAL_JTAG_BUF_SIZE];
static volatile bool terminal_connected = false;
static void usb_serial_jtag_isr_handler(void *arg) {
uint32_t flags = usb_serial_jtag_ll_get_intsts_mask();
if (flags & USB_SERIAL_JTAG_INTR_SOF) {
usb_serial_jtag_ll_clr_intsts_mask(USB_SERIAL_JTAG_INTR_SOF);
}
if (flags & USB_SERIAL_JTAG_INTR_SERIAL_OUT_RECV_PKT) {
usb_serial_jtag_ll_clr_intsts_mask(USB_SERIAL_JTAG_INTR_SERIAL_OUT_RECV_PKT);
size_t req_len = ringbuf_free(&stdin_ringbuf);
if (req_len > USB_SERIAL_JTAG_BUF_SIZE) {
req_len = USB_SERIAL_JTAG_BUF_SIZE;
}
size_t len = usb_serial_jtag_ll_read_rxfifo(rx_buf, req_len);
for (size_t i = 0; i < len; ++i) {
if (rx_buf[i] == mp_interrupt_char) {
mp_sched_keyboard_interrupt();
} else {
ringbuf_put(&stdin_ringbuf, rx_buf[i]);
}
}
mp_hal_wake_main_task_from_isr();
}
}
void usb_serial_jtag_init(void) {
usb_serial_jtag_ll_clr_intsts_mask(USB_SERIAL_JTAG_INTR_SERIAL_OUT_RECV_PKT |
USB_SERIAL_JTAG_INTR_SOF);
usb_serial_jtag_ll_ena_intr_mask(USB_SERIAL_JTAG_INTR_SERIAL_OUT_RECV_PKT |
USB_SERIAL_JTAG_INTR_SOF);
ESP_ERROR_CHECK(esp_intr_alloc(ETS_USB_SERIAL_JTAG_INTR_SOURCE, ESP_INTR_FLAG_LEVEL1,
usb_serial_jtag_isr_handler, NULL, NULL));
}
void usb_serial_jtag_tx_strn(const char *str, size_t len) {
while (len) {
size_t l = len;
if (l > USB_SERIAL_JTAG_PACKET_SZ_BYTES) {
l = USB_SERIAL_JTAG_PACKET_SZ_BYTES;
}
portTickType start_tick = xTaskGetTickCount();
while (!usb_serial_jtag_ll_txfifo_writable()) {
portTickType now_tick = xTaskGetTickCount();
if (!terminal_connected || now_tick > (start_tick + pdMS_TO_TICKS(200))) {
terminal_connected = false;
return;
}
}
terminal_connected = true;
l = usb_serial_jtag_ll_write_txfifo((const uint8_t *)str, l);
usb_serial_jtag_ll_txfifo_flush();
str += l;
len -= l;
}
}
#endif // CONFIG_ESP_CONSOLE_USB_SERIAL_JTAG
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/usb_serial_jtag.c | C | apache-2.0 | 3,693 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2021 Patrick Van Oosterwijck
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#ifndef MICROPY_INCLUDED_ESP32_USB_SERIAL_JTAG_H
#define MICROPY_INCLUDED_ESP32_USB_SERIAL_JTAG_H
void usb_serial_jtag_init(void);
void usb_serial_jtag_tx_strn(const char *str, size_t len);
#endif // MICROPY_INCLUDED_ESP32_USB_SERIAL_JTAG_H
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/usb_serial_jtag.h | C | apache-2.0 | 1,475 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* Development of the code in this file was sponsored by Microbric Pty Ltd
*
* The MIT License (MIT)
*
* Copyright (c) Alibaba AIoT
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include "utility.h"
bool callback_to_python_LoBo(mp_obj_t function, mp_obj_t arg, void *carg)
{
bool ret = false;
if (function != MP_OBJ_NULL && mp_obj_is_callable(function)) {
ret = mp_sched_schedule_LoBo(function, arg, carg);
if (ret == false) {
printf("[utility]: schedule queue is full !!!!\r\n");
}
mp_hal_wake_main_task_from_isr();
}
return ret;
}
mp_obj_t mp_obj_new_strn(const char *data)
{
return mp_obj_new_str(data, strlen(data));
}
const char *get_str_from_dict(mp_obj_t dict, const char *key)
{
mp_obj_t value_obj = mp_obj_dict_get(dict, mp_obj_new_strn(key));
return (char *)mp_obj_str_get_str(value_obj);
}
int get_int_from_dict(mp_obj_t dict, const char *key)
{
mp_obj_t value_obj = mp_obj_dict_get(dict, mp_obj_new_strn(key));
return mp_obj_get_int(value_obj);
}
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/utility.c | C | apache-2.0 | 2,160 |
#ifndef PY_OBJ_UTILITY_H
#define PY_OBJ_UTILITY_H
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include "py/builtin.h"
#include "py/gc.h"
#include "py/mperrno.h"
#include "py/obj.h"
#include "py/runtime.h"
#include "py/mpstate.h"
extern void mp_hal_wake_main_task_from_isr();
bool callback_to_python_LoBo(mp_obj_t function, mp_obj_t arg, void *carg);
mp_obj_t mp_obj_new_strn(const char *data);
const char *get_str_from_dict(mp_obj_t dict, const char *key);
int get_int_from_dict(mp_obj_t dict, const char *key);
#endif
| YifuLiu/AliOS-Things | components/py_engine/adapter/esp32/utility.h | C | apache-2.0 | 563 |
cmake_minimum_required(VERSION 3.12)
# Set main target and component locations
set(MICROPY_TARGET micropython)
# Do not compile testCCompiler.c file for cmake
SET (CMAKE_C_COMPILER_WORKS 1)
SET (CMAKE_CXX_COMPILER_WORKS 1)
set(CMAKE_TRY_COMPILE_TARGET_TYPE "STATIC_LIBRARY")
# Do not generate -arch option for macOS M1
set(CMAKE_SYSTEM_NAME Generic)
# Define the top-level project
project(${MICROPY_TARGET})
set(HAAS_PLATFORM TRUE)
# Set location of base MicroPython directory.
if(NOT MICROPY_DIR)
get_filename_component(MICROPY_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../engine ABSOLUTE)
endif()
# Set the location of AOS components directory.
if(NOT AOS_COMPONENTS_DIR)
get_filename_component(AOS_COMPONENTS_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../../ ABSOLUTE)
endif()
# Set the location of AOS hardware directory.
if(NOT AOS_HARDWARE_DIR)
get_filename_component(AOS_HARDWARE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../../../hardware ABSOLUTE)
endif()
# Set the location of AOS hardware directory.
if(NOT AOS_KERNEL_DIR)
get_filename_component(AOS_KERNEL_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../../../kernel ABSOLUTE)
endif()
# Set the location of AOS components directory.
if(NOT HAAS_ENGINE_DIR)
get_filename_component(HAAS_ENGINE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../ ABSOLUTE)
endif()
# Include core extmod components.
include(${MICROPY_DIR}/../modules/portmod.cmake)
include(${MICROPY_DIR}/../external/external.cmake)
# Include core source components.
include(${MICROPY_DIR}/py/py.cmake)
if(NOT CMAKE_BUILD_EARLY_EXPANSION)
include(${MICROPY_DIR}/py/usermod.cmake)
include(${MICROPY_DIR}/extmod/extmod.cmake)
if(MICROPY_PY_LVGL)
set(LVGL_DIR ${MICROPY_DIR}/lib/lv_bindings/lvgl)
set(LV_CONFIG_DIR ${MICROPY_DIR}/../modules/display/haas)
include(${MICROPY_DIR}/lib/lv_bindings/bindings.cmake)
endif()
endif()
set(MICROPY_QSTRDEFS_PORT
${PROJECT_SOURCE_DIR}/qstrdefsport.h
)
set(MICROPY_SOURCE_SHARED
${MICROPY_DIR}/shared/readline/readline.c
${MICROPY_DIR}/shared/netutils/netutils.c
${MICROPY_DIR}/shared/timeutils/timeutils.c
${MICROPY_DIR}/shared/runtime/interrupt_char.c
${MICROPY_DIR}/shared/runtime/stdout_helpers.c
${MICROPY_DIR}/shared/runtime/sys_stdio_mphal.c
${MICROPY_DIR}/shared/runtime/pyexec.c
${MICROPY_DIR}/shared/runtime/gchelper_generic.c
)
set(MICROPY_SOURCE_LIB
# ${MICROPY_DIR}/lib/littlefs/lfs1.c
# ${MICROPY_DIR}/lib/littlefs/lfs1_util.c
# ${MICROPY_DIR}/lib/littlefs/lfs2.c
# ${MICROPY_DIR}/lib/littlefs/lfs2_util.c
# ${MICROPY_DIR}/lib/mbedtls_errors/mp_mbedtls_errors.c
# ${MICROPY_DIR}/lib/oofatfs/ff.c
# ${MICROPY_DIR}/lib/oofatfs/ffunicode.c
)
set(MICROPY_SOURCE_DRIVERS
${MICROPY_DIR}/drivers/bus/softspi.c
${MICROPY_DIR}/drivers/dht/dht.c
)
set(MICROPY_SOURCE_PORT
${PROJECT_SOURCE_DIR}/gccollect.c
${PROJECT_SOURCE_DIR}/help.c
${PROJECT_SOURCE_DIR}/machine_adc.c
${PROJECT_SOURCE_DIR}/machine_dac.c
${PROJECT_SOURCE_DIR}/machine_hw_i2c.c
${PROJECT_SOURCE_DIR}/machine_hw_spi.c
${PROJECT_SOURCE_DIR}/machine_pin.c
${PROJECT_SOURCE_DIR}/machine_pwm.c
${PROJECT_SOURCE_DIR}/machine_rtc.c
${PROJECT_SOURCE_DIR}/machine_sw_timer.c
${PROJECT_SOURCE_DIR}/machine_timer.c
${PROJECT_SOURCE_DIR}/machine_touchpad.c
${PROJECT_SOURCE_DIR}/machine_uart.c
${PROJECT_SOURCE_DIR}/machine_wdt.c
${PROJECT_SOURCE_DIR}/modbattery.c
${PROJECT_SOURCE_DIR}/modcharger.c
${PROJECT_SOURCE_DIR}/modipc.c
${PROJECT_SOURCE_DIR}/modmachine.c
${PROJECT_SOURCE_DIR}/modpm.c
${PROJECT_SOURCE_DIR}/modsocket.c
${PROJECT_SOURCE_DIR}/modsysteminfo.c
${PROJECT_SOURCE_DIR}/moduos.c
${PROJECT_SOURCE_DIR}/modutime.c
${PROJECT_SOURCE_DIR}/mphalport.c
${PROJECT_SOURCE_DIR}/mpsalport.c
${PROJECT_SOURCE_DIR}/mpstdinport.c
${PROJECT_SOURCE_DIR}/mpthreadport.c
${PROJECT_SOURCE_DIR}/utility.c
${PROJECT_SOURCE_DIR}/modnetwork.c
)
set(MICROPY_SOURCE_QSTR
${MICROPY_SOURCE_PY}
${MICROPY_SOURCE_EXTMOD}
${MICROPY_SOURCE_USERMOD}
${MICROPY_SOURCE_SHARED}
${MICROPY_SOURCE_LIB}
${MICROPY_SOURCE_PORT}
${MICROPY_SOURCE_MODULES_PORT}
${MICROPY_SOURCE_EXTERNAL}
${LV_SRC}
)
set(AOS_SDK_COMPONENTS
mbedtls
)
# Define mpy-cross flags, for use with frozen code.
set(MICROPY_CROSS_FLAGS -march=armv7m)
# Set the location of this port's directory.
set(MICROPY_PORT_DIR ${CMAKE_SOURCE_DIR})
# Set the board if it's not already set.
if(NOT MICROPY_BOARD)
set(MICROPY_BOARD HaaSEDUk1)
endif()
# Set the board directory and check that it exists.
if(NOT MICROPY_BOARD_DIR)
set(MICROPY_BOARD_DIR ${MICROPY_PORT_DIR}/boards/${MICROPY_BOARD})
endif()
if(NOT EXISTS ${MICROPY_BOARD_DIR}/mpconfigboard.cmake)
message(FATAL_ERROR "Invalid MICROPY_BOARD specified: ${MICROPY_BOARD}")
endif()
if (NOT MICROPY_FROZEN_MANIFEST)
set(MICROPY_FROZEN_MANIFEST ${PROJECT_SOURCE_DIR}/boards/manifest_release.py)
endif()
# Include board config
include(${MICROPY_BOARD_DIR}/mpconfigboard.cmake)
add_library(${MICROPY_TARGET})
# Set compile options for this port.
target_compile_definitions(${MICROPY_TARGET} PUBLIC
${MICROPY_DEF_MODULES_PORT}
${MICROPY_DEF_CORE}
FFCONF_H=\"${MICROPY_OOFATFS_DIR}/ffconf.h\"
LFS1_NO_MALLOC LFS1_NO_DEBUG LFS1_NO_WARN LFS1_NO_ERROR LFS1_NO_ASSERT
LFS2_NO_MALLOC LFS2_NO_DEBUG LFS2_NO_WARN LFS2_NO_ERROR LFS2_NO_ASSERT
)
target_sources(${MICROPY_TARGET} PRIVATE
${MICROPY_SOURCE_PY}
${MICROPY_SOURCE_EXTMOD}
${MICROPY_SOURCE_LIB}
${MICROPY_SOURCE_DRIVERS}
${MICROPY_SOURCE_PORT}
${MICROPY_SOURCE_USERMOD}
${MICROPY_SOURCE_SHARED}
${MICROPY_SOURCE_MODULES_PORT}
${MICROPY_SOURCE_EXTERNAL}
${LV_SRC}
)
target_include_directories(${MICROPY_TARGET} PRIVATE
${MICROPY_INC_CORE}
${MICROPY_INC_USERMOD}
${MICROPY_BOARD_DIR}
${PROJECT_SOURCE_DIR}
${CMAKE_BINARY_DIR}
${MICROPY_INC_MODULES_PORT}
${MICROPY_INC_EXTERNAL}
)
target_link_libraries(${MICROPY_TARGET}
${AOS_SDK_COMPONENTS}
)
# Disable some warnings to keep the build output clean.
target_compile_options(${MICROPY_TARGET} PUBLIC
-Wno-clobbered
-Wno-deprecated-declarations
-Wno-missing-field-initializers
)
target_link_libraries(${MICROPY_TARGET} micropy_extmod_btree)
target_link_libraries(${MICROPY_TARGET} usermod)
# Collect all the include directories and compile definitions for the aos-sdk components.
foreach(comp ${AOS_SDK_COMPONENTS})
micropy_gather_target_properties(${comp})
endforeach()
target_include_directories(${MICROPY_TARGET} PRIVATE
${AOS_COMPONENTS_DIR}/mbedtls/include
${AOS_COMPONENTS_DIR}/mbedtls/platform/include
${AOS_COMPONENTS_DIR}/mbedtls/platform/aos/include
${AOS_COMPONENTS_DIR}/lwip/lwip2.0.0/src/include
${AOS_COMPONENTS_DIR}/lwip/lwip2.0.0/include
${AOS_COMPONENTS_DIR}/fatfs/include
${AOS_COMPONENTS_DIR}/drivers/peripheral/uart/include
${AOS_COMPONENTS_DIR}/drivers/peripheral/gpio/include
${AOS_COMPONENTS_DIR}/drivers/peripheral/flash/include
${AOS_COMPONENTS_DIR}/drivers/core/base/include
${AOS_COMPONENTS_DIR}/osal_aos/include/
${AOS_COMPONENTS_DIR}/vfs/include/
${AOS_KERNEL_DIR}/rhino/include
${AOS_HARDWARE_DIR}/arch/armv8m/include
)
if(MICROPY_BOARD STREQUAL "HaaSEDUk1")
target_include_directories(${MICROPY_TARGET} PRIVATE
${AOS_HARDWARE_DIR}/chip/haas1000/drivers/platform/hal
${AOS_HARDWARE_DIR}/chip/haas1000
${AOS_HARDWARE_DIR}/chip/haas1000/aos/arch
${AOS_HARDWARE_DIR}/chip/haas1000/aos
${AOS_HARDWARE_DIR}/chip/haas1000/drivers/rtos/rhino
${AOS_HARDWARE_DIR}/chip/haas1000/drivers/rtos/rhino/include
${AOS_HARDWARE_DIR}/board/haaseduk1/config
)
elseif(MICROPY_BOARD STREQUAL "HaaS200")
target_include_directories(${MICROPY_TARGET} PRIVATE
${AOS_HARDWARE_DIR}/chip/rtl872xd
${AOS_HARDWARE_DIR}/board/haas200/config
${AOS_HARDWARE_DIR}/chip/rtl872xd/arch
)
endif()
add_definitions("-DRHINO_CONFIG_MM_TLF_BLK_SIZE=0x800")
# Include the main MicroPython cmake rules.
include(${MICROPY_DIR}/py/mkrules.cmake)
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/CMakeLists.txt | CMake | apache-2.0 | 8,175 |
/*
* Copyright (C) 2015-2020 Alibaba Group Holding Limited
*/
#ifndef __AMP_MACHINE_CONFIG_H__
#define __AMP_MACHINE_CONFIG_H__
/* python engine root dir define */
#define MP_FS_ROOT_DIR "/data"
#define MP_FS_EXT_ROOT_DIR "/sdcard"
#define AMP_FS_ROOT_DIR MP_FS_ROOT_DIR "/pyamp"
#define AMP_FS_EXT_ROOT_DIR MP_FS_EXT_ROOT_DIR "/pyamp"
#define MP_REPL_UART_PORT 0
#define MP_REPL_UART_BAUDRATE 1500000UL
#define MP_RECOVERY_UART_PORT 0
#define MP_RECOVERY_UART_PORT_BAUDRATE 1500000UL
#endif // __AMP_MACHINE_CONFIG_H__
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/board_config.h | C | apache-2.0 | 614 |
if(NOT MICROPY_FROZEN_MANIFEST)
set(MICROPY_FROZEN_MANIFEST ${MICROPY_PORT_DIR}/boards/manifest.py)
endif()
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/boards/HaaS200/mpconfigboard.cmake | CMake | apache-2.0 | 112 |
#define MICROPY_HW_BOARD_NAME "HaaS200 module"
#define MICROPY_HW_MCU_NAME "HaaS200"
#define MICROPY_SW_VENDOR_NAME "HaaSPython"
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/boards/HaaS200/mpconfigboard.h | C | apache-2.0 | 129 |
if(NOT MICROPY_FROZEN_MANIFEST)
set(MICROPY_FROZEN_MANIFEST ${MICROPY_PORT_DIR}/boards/manifest.py)
endif()
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/boards/HaaSEDUk1/mpconfigboard.cmake | CMake | apache-2.0 | 112 |
#define MICROPY_HW_BOARD_NAME "EDUk1 module"
#define MICROPY_HW_MCU_NAME "EDUk1"
#define MICROPY_SW_VENDOR_NAME "HaaSPython"
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/boards/HaaSEDUk1/mpconfigboard.h | C | apache-2.0 | 125 |
freeze("$(PORT_DIR)/modules")
freeze("$(MPY_DIR)/tools", ("upip.py", "upip_utarfile.py"))
freeze("$(MPY_DIR)/drivers/dht", "dht.py")
freeze("$(MPY_DIR)/drivers/onewire")
include("$(MPY_DIR)/extmod/uasyncio/manifest.py")
include("$(MPY_DIR)/extmod/webrepl/manifest.py")
include("$(MPY_DIR)/drivers/neopixel/manifest.py")
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/boards/manifest.py | Python | apache-2.0 | 320 |
include("manifest.py")
freeze("$(MPY_LIB_DIR)/python-ecosys/urequests", "urequests.py")
freeze("$(MPY_LIB_DIR)/micropython/upysh", "upysh.py")
freeze("$(MPY_LIB_DIR)/micropython/umqtt.simple", "umqtt/simple.py")
freeze("$(MPY_LIB_DIR)/micropython/umqtt.robust", "umqtt/robust.py")
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/boards/manifest_release.py | Python | apache-2.0 | 283 |
import kv
import netmgr as nm
import _thread
import time
def _connect_wifi():
time.sleep_ms(1000 * 2)
ssid = kv.get('_amp_wifi_ssid')
passwd = kv.get('_amp_wifi_passwd')
if isinstance(ssid, str) and isinstance(passwd, str):
nm.init()
if nm.getStatus() == 5:
pass
else:
nm.connect(ssid, passwd)
def _on_get_url(url):
kv.set('_amp_pyapp_url', url)
execfile('/lib/appOta.py')
channel = kv.get('app_upgrade_channel')
if channel != "disable":
import online_upgrade
online_upgrade.on(_on_get_url)
try:
_thread.start_new_thread(_connect_wifi, ())
#_thread.stack_size(10 * 1024)
except Exception as e:
print(e)
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/fs/boot.py | Python | apache-2.0 | 723 |
"""
Copyright (C) 2015-2020 Alibaba Group Holding Limited
The driver for AP3216C chip, The AP3216C is an integrated ALS & PS module
that includes a digital ambient light sensor [ALS], a proximity sensor [PS],
and an IR LED in a single package.
"""
from micropython import const
from driver import I2C
from utime import sleep_ms
# System Register
AP3216C_SYS_CONFIGURATION_REG = const(0x00)
AP3216C_SYS_INT_STATUS_REG = const(0x01)
AP3216C_SYS_INT_CLEAR_MANNER_REG = const(0x02)
AP3216C_IR_DATA_L_REG = const(0x0A)
AP3216C_IR_DATA_H_REG = const(0x0B)
AP3216C_ALS_DATA_L_REG = const(0x0C)
AP3216C_ALS_DATA_H_REG = const(0x0D)
AP3216C_PS_DATA_L_REG = const(0x0E)
AP3216C_PS_DATA_H_REG = const(0x0F)
# ALS Register
AP3216C_ALS_CONFIGURATION_REG = const(0x10)
AP3216C_ALS_CALIBRATION_REG = const(0x19)
AP3216C_ALS_THRESHOLD_LOW_L_REG = const(0x1A)
AP3216C_ALS_THRESHOLD_LOW_H_REG = const(0x1B)
AP3216C_ALS_THRESHOLD_HIGH_L_REG = const(0x1C)
AP3216C_ALS_THRESHOLD_HIGH_H_REG = const(0x1D)
# PS Register
AP3216C_PS_CONFIGURATION_REG = const(0x20)
AP3216C_PS_LED_DRIVER_REG = const(0x21)
AP3216C_PS_INT_FORM_REG = const(0x22)
AP3216C_PS_MEAN_TIME_REG = const(0x23)
AP3216C_PS_LED_WAITING_TIME_REG = const(0x24)
AP3216C_PS_CALIBRATION_L_REG = const(0x28)
AP3216C_PS_CALIBRATION_H_REG = const(0x29)
AP3216C_PS_THRESHOLD_LOW_L_REG = const(0x2A)
AP3216C_PS_THRESHOLD_LOW_H_REG = const(0x2B)
AP3216C_PS_THRESHOLD_HIGH_L_REG = const(0x2C)
AP3216C_PS_THRESHOLD_HIGH_H_REG = const(0x2D)
#mode value
AP3216C_MODE_POWER_DOWN = const(0x0)
AP3216C_MODE_ALS = const(0x1)
AP3216C_MODE_PS = const(0x2)
AP3216C_MODE_ALS_AND_PS = const(0x3)
AP3216C_MODE_SW_RESET = const(0x4)
AP3216C_MODE_ALS_ONCE = const(0x5)
AP3216C_MODE_PS_ONCE = const(0x6)
AP3216C_MODE_ALS_AND_PS_ONCE = const(0x7)
#ap3216c_int_clear_manner
AP3216C_INT_CLEAR_MANNER_BY_READING = const(0x0)
AP3216C_ALS_CLEAR_MANNER_BY_SOFTWARE = const(0x1)
#als_range
AP3216C_ALS_RANGE_20661 = const(0x0)
AP3216C_ALS_RANGE_5162 = const(0x1)
AP3216C_ALS_RANGE_1291 = const(0x2)
AP3216C_ALS_RANGE_323 = const(0x3)
#als_range
AP3216C_PS_GAIN1 = const(0x0)
AP3216C_PS_GAIN2 = const(0x1)
AP3216C_PS_GAIN4 = const(0x2)
AP3216C_PS_GAIN8 = const(0x3)
AP3216C_SYSTEM_MODE = const(0x0)
AP3216C_INT_PARAM = const(0x1)
AP3216C_ALS_RANGE = const(0x2)
AP3216C_ALS_PERSIST = const(0x3)
AP3216C_ALS_CALIBRATION = const(0x4)
AP3216C_ALS_LOW_THRESHOLD_L = const(0x5)
AP3216C_ALS_LOW_THRESHOLD_H = const(0x6)
AP3216C_ALS_HIGH_THRESHOLD_L = const(0x7)
AP3216C_ALS_HIGH_THRESHOLD_H = const(0x8)
AP3216C_PS_INTEGRATED_TIME = const(0x9)
AP3216C_PS_GAIN = const(0xa)
AP3216C_PS_PERSIST = const(0xb)
AP3216C_PS_LED_CONTROL = const(0xc)
AP3216C_PS_LED_DRIVER_RATIO = const(0xd)
AP3216C_PS_INT_MODE = const(0xe)
AP3216C_PS_MEAN_TIME = const(0xf)
AP3216C_PS_WAITING_TIME = const(0x10)
AP3216C_PS_CALIBRATION_L = const(0x11)
AP3216C_PS_CALIBRATION_H = const(0x12)
AP3216C_PS_LOW_THRESHOLD_L = const(0x13)
AP3216C_PS_LOW_THRESHOLD_H = const(0x14)
AP3216C_PS_HIGH_THRESHOLD_L = const(0x15)
AP3216C_PS_HIGH_THRESHOLD_H = const(0x16)
class AP3216C(object):
"""
This class implements ap3216c chip's defs.
"""
def __init__(self, i2cDev):
self._i2cDev = None
if not isinstance(i2cDev, I2C):
raise ValueError("parameter is not an I2C object")
# make AP3216C's internal object points to i2cDev
self._i2cDev = i2cDev
self.init()
# 写寄存器的值
def write_reg(self, addr, data):
msgbuf = bytearray([data])
self._i2cDev.memWrite(msgbuf, addr, 8)
# print("--> write addr " + str(addr) + ", value = " + str(msgbuf))
# 读寄存器的值
def read_regs(self, addr, len):
buf = bytearray(len)
self._i2cDev.memRead(buf, addr, 8)
# print("--> read " + str(len) + " bytes from addr " + str(addr) + ", " + str(len) + " bytes value = " + str(buf))
return buf
# 软件复位传感器
def reset_sensor(self):
self.write_reg(AP3216C_SYS_CONFIGURATION_REG, AP3216C_MODE_SW_RESET); # reset
def read_low_and_high(self, reg, len):
data = self.read_regs(reg, len)[0] | (self.read_regs(reg + 1, len)[0] << len * 8) # 读低字节 - 读高字节 - 合并数据
if (data > (1 << 15)):
data = data - (1<<16)
return data
def ap3216c_get_IntStatus(self):
# 读中断状态寄存器
IntStatus = self.read_regs(AP3216C_SYS_INT_STATUS_REG, 1)[0]
# IntStatus 第 0 位表示 ALS 中断，第 1 位表示 PS 中断。
return IntStatus # 返回状态
def ap3216c_int_init(self):
#print("ap3216c_int_init")
pass
#配置 中断输入引脚
def ap3216c_int_Config(self):
#print("ap3216c_int_Config")
pass
#初始化入口
def init(self):
# reset ap3216c
self.reset_sensor()
sleep_ms(100)
self.ap3216c_set_param(AP3216C_SYSTEM_MODE, AP3216C_MODE_ALS_AND_PS)
sleep_ms(150) # delay at least 112.5ms
self.ap3216c_int_Config()
self.ap3216c_int_init()
# This function reads light by ap3216c sensor measurement
# @param no
# @return the ambient light converted to float data.
#
def ap3216c_read_ambient_light(self):
read_data = self.read_low_and_high(AP3216C_ALS_DATA_L_REG, 1)
range = self.ap3216c_get_param(AP3216C_ALS_RANGE)
#print("ap3216c_read_ambient_light read_data is " , read_data, range)
if (range == AP3216C_ALS_RANGE_20661):
brightness = 0.35 * read_data # sensor ambient light converse to reality
elif (range == AP3216C_ALS_RANGE_5162):
brightness = 0.0788 * read_data # sensor ambient light converse to reality
elif (range == AP3216C_ALS_RANGE_1291):
brightness = 0.0197 * read_data # sensor ambient light converse to reality
elif (range == AP3216C_ALS_RANGE_323):
brightness = 0.0049 * read_data # sensor ambient light converse to reality
return brightness
#This function reads proximity by ap3216c sensor measurement
#@param no
#@return the proximity data.
def ap3216c_read_ps_data(self):
read_data = self.read_low_and_high(AP3216C_PS_DATA_L_REG, 1) # read two data
#print("ap3216c_read_ps_data read_data is " , read_data);
if (1 == ((read_data >> 6) & 0x01 or (read_data >> 14) & 0x01)) :
return 55555 # 红外过高（IR），PS无效 返回一个 55555 的无效数据
proximity = (read_data & 0x000f) + (((read_data >> 8) & 0x3f) << 4)
# sensor proximity converse to reality
if (proximity > (1 << 15)) :
proximity = proximity - (1<<16)
proximity |= read_data & 0x8000 # 取最高位，0 表示物体远离，1 表示物体靠近
return proximity # proximity 后十位是数据位，最高位为状态位
#This function reads ir by ap3216c sensor measurement
#@param no
#@return the ir data.
def ap3216c_read_ir_data(self):
read_data = self.read_low_and_high(AP3216C_IR_DATA_L_REG, 1) # read two data
#print("ap3216c_read_ir_data read_data is" , read_data);
proximity = (read_data & 0x0003) + ((read_data >> 8) & 0xFF)
# sensor proximity converse to reality
if (proximity > (1 << 15)) :
proximity = proximity - (1<<16)
return proximity
#This function sets parameter of ap3216c sensor
#@param cmd the parameter cmd of device
#@param value for setting value in cmd register
#@return the setting parameter status,RT_EOK reprensents setting successfully.
def ap3216c_set_param(self, cmd, value):
if cmd == AP3216C_SYSTEM_MODE:
# default 000,power down
self.write_reg(AP3216C_SYS_CONFIGURATION_REG, value)
elif cmd == AP3216C_INT_PARAM:
self.write_reg(AP3216C_SYS_INT_CLEAR_MANNER_REG, value)
elif cmd == AP3216C_ALS_RANGE:
args = self.read_regs(AP3216C_ALS_CONFIGURATION_REG, 1)[0]
args &= 0xcf
args |= value << 4
self.write_reg(AP3216C_ALS_CONFIGURATION_REG, args)
elif cmd == AP3216C_ALS_PERSIST:
args = self.read_regs(AP3216C_ALS_CONFIGURATION_REG, 1)[0]
args &= 0xf0
args |= value
self.write_reg(AP3216C_ALS_CONFIGURATION_REG, args)
elif cmd == AP3216C_ALS_LOW_THRESHOLD_L:
self.write_reg(AP3216C_ALS_THRESHOLD_LOW_L_REG, value)
elif cmd == AP3216C_ALS_LOW_THRESHOLD_H:
self.write_reg(AP3216C_ALS_THRESHOLD_LOW_H_REG, value)
elif cmd == AP3216C_ALS_HIGH_THRESHOLD_L:
self.write_reg(AP3216C_ALS_THRESHOLD_HIGH_L_REG, value)
elif cmd == AP3216C_ALS_HIGH_THRESHOLD_H:
self.write_reg(AP3216C_ALS_THRESHOLD_HIGH_H_REG, value)
elif cmd == AP3216C_PS_GAIN:
args = self.read_regs(AP3216C_PS_CONFIGURATION_REG, 1)[0]
args &= 0xf3
args |= value
self.write_reg(AP3216C_PS_CONFIGURATION_REG, args)
elif cmd == AP3216C_PS_PERSIST:
args = self.read_regs(AP3216C_PS_CONFIGURATION_REG, 1)[0]
args &= 0xfc
args |= value
self.write_reg(AP3216C_PS_CONFIGURATION_REG, args)
elif cmd == AP3216C_PS_LOW_THRESHOLD_L:
self.write_reg(AP3216C_PS_THRESHOLD_LOW_L_REG, value)
elif cmd == AP3216C_PS_LOW_THRESHOLD_H:
self.write_reg(AP3216C_PS_THRESHOLD_LOW_H_REG, value)
elif cmd == AP3216C_PS_HIGH_THRESHOLD_L:
self.write_reg(AP3216C_PS_THRESHOLD_HIGH_L_REG, value)
elif cmd == AP3216C_PS_HIGH_THRESHOLD_H:
self.write_reg(AP3216C_PS_THRESHOLD_HIGH_H_REG, value)
#This function gets parameter of ap3216c sensor
#@param cmd the parameter cmd of device
#@param value to get value in cmd register
#@return the getting parameter status,RT_EOK reprensents getting successfully.
def ap3216c_get_param(self, cmd):
if cmd == AP3216C_SYSTEM_MODE:
value = self.read_regs(AP3216C_SYS_CONFIGURATION_REG, 1)[0]
elif cmd == AP3216C_INT_PARAM:
value = self.read_regs(AP3216C_SYS_INT_CLEAR_MANNER_REG, 1)[0]
elif cmd == AP3216C_ALS_RANGE:
value = self.read_regs(AP3216C_ALS_CONFIGURATION_REG, 1)[0]
temp = (value & 0xff) >> 4
value = temp
elif cmd == AP3216C_ALS_PERSIST:
temp = self.read_regs(AP3216C_ALS_CONFIGURATION_REG, 1)[0]
temp = value & 0x0f
value = temp
elif cmd == AP3216C_ALS_LOW_THRESHOLD_L:
value = self.read_regs(AP3216C_ALS_THRESHOLD_LOW_L_REG, 1)[0]
elif cmd == AP3216C_ALS_LOW_THRESHOLD_H:
value = self.read_regs(AP3216C_ALS_THRESHOLD_LOW_H_REG, 1)[0]
elif cmd == AP3216C_ALS_HIGH_THRESHOLD_L:
value = self.read_regs(AP3216C_ALS_THRESHOLD_HIGH_L_REG, 1)[0]
elif cmd == AP3216C_ALS_HIGH_THRESHOLD_H:
value = self.read_regs(AP3216C_ALS_THRESHOLD_HIGH_H_REG, 1)[0]
elif cmd == AP3216C_PS_GAIN:
temp = self.read_regs(AP3216C_PS_CONFIGURATION_REG, 1)[0]
value = (temp & 0xc) >> 2
elif cmd == AP3216C_PS_PERSIST:
temp = self.read_regs(AP3216C_PS_CONFIGURATION_REG, 1)[0]
value = temp & 0x3
elif cmd == AP3216C_PS_LOW_THRESHOLD_L:
value = self.read_regs(AP3216C_PS_THRESHOLD_LOW_L_REG, 1)[0]
elif cmd == AP3216C_PS_LOW_THRESHOLD_H:
value = self.read_regs(AP3216C_PS_THRESHOLD_LOW_H_REG, 1)[0]
elif cmd == AP3216C_PS_HIGH_THRESHOLD_L:
value = self.read_regs(AP3216C_PS_THRESHOLD_HIGH_L_REG, 1)[0]
elif cmd == AP3216C_PS_HIGH_THRESHOLD_H:
value = self.read_regs(AP3216C_PS_THRESHOLD_HIGH_H_REG, 1)[0]
return value
def getData(self):
ap3216c_dict = {'brightness': 0, 'ir': 0, 'ps': 0}
brightness = self.ap3216c_read_ambient_light()
ir_data = self.ap3216c_read_ir_data()
ps_data = self.ap3216c_read_ps_data()
ap3216c_dict['brightness'] = brightness
ap3216c_dict['ir'] = ir_data
ap3216c_dict['ps'] = ps_data
return ap3216c_dict
# 获取光照强度值
def getIlluminance(self):
if not self._i2cDev:
raise ValueError("i2cObj is not initialized")
return self.ap3216c_read_ambient_light()
# 获取接近状态：接近返回True，否则返回False
def isProximate(self):
if not self._i2cDev:
raise ValueError("i2cObj is not initialized")
ps = self.ap3216c_read_ps_data()
if ((ps >> 15) & 1):
return True
else:
return False
if __name__ == "__main__":
'''
The below i2c configuration is needed in your board.json.
"ap3216c": {
"type": "I2C",
"port": 1,
"addrWidth": 7,
"freq": 100000,
"mode": "master",
"devAddr": 30
}
'''
print("Testing ap3216c ...")
i2cDev = I2C()
i2cDev.open("ap3216c")
ap3216cDev = AP3216C(i2cDev)
illuminance = ap3216cDev.getIlluminance()
print("The illuminance is:", illuminance)
proxi = ap3216cDev.isProximate()
print("The proximity state is", proxi)
data = ap3216cDev.getData()
print("The total datais: ", data)
i2cDev.close()
del ap3216cDev
print("Test ap3216c done!")
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/fs/lib/ap3216c/ap3216c.py | Python | apache-2.0 | 13,749 |
import uos as os
import uerrno as errno
import ujson as json
import uzlib
import upip_utarfile as tarfile
import gc
import time
import ussl
import usocket
import kv
import time
file_buf = bytearray(128)
def install_pkg(package_url, install_path):
gzdict_sz = 16 + 15
f1 = url_open(package_url)
if (isinstance(f1, (str, bytes, bytearray)) == True):
return f1
try:
f2 = uzlib.DecompIO(f1, gzdict_sz)
f3 = tarfile.TarFile(fileobj=f2)
install_tar(f3, install_path)
except Exception as e:
print(e)
return ("UNTAR_FILE_FAIL")
finally:
f1.close()
del f3
del f2
gc.collect()
#print('install_pkg success')
return 'SUCCESS'
def download_save_file(file_url, fname):
global file_buf
f1 = url_open(file_url)
if (isinstance(f1, (str, bytes, bytearray)) == True):
#print(f1)
return f1
#print(fname)
_makedirs(fname)
with open(fname, "wb") as outf:
while True:
sz = f1.readinto(file_buf)
if not sz:
break
outf.write(file_buf, sz)
outf.close()
f1.close()
del f1
#print('download_save_file success')
return 'SUCCESS'
def url_open(url):
proto, _, host, urlpath = url.split('/', 3)
try:
port = 443
if ":" in host:
host, port = host.split(":")
port = int(port)
ai = usocket.getaddrinfo(host, port, 0, usocket.SOCK_STREAM)
except OSError as e:
print("Error:", "Unable to resolve %s (no Internet?)" % host, e)
return 'HOST_RESOLVED_FAIL'
# print("Address infos:", ai)
ai = ai[0]
s = usocket.socket(ai[0], ai[1], ai[2])
try:
s.connect(ai[-1])
if proto == "https:":
s = ussl.wrap_socket(s, server_hostname=host)
s.write("GET /%s HTTP/1.0\r\nHost: %s:%s\r\n\r\n" %
(urlpath, host, port))
l = s.readline()
protover, status, msg = l.split(None, 2)
if status != b"200":
if status == b"404" or status == b"301" or status == b"403":
return ("Package not found")
else:
print("status is {}".format(status))
return (status)
while True:
l = s.readline()
if not l:
return ("Unexpected EOF in HTTP headers")
if l == b'\r\n':
break
except Exception as e:
s.close()
print(e)
return ('SOCKET_ERROR')
return s
def _makedirs(name, mode=0o777):
ret = False
s = ""
comps = name.rstrip("/").split("/")[:-1]
if comps[0] == "":
s = "/"
for c in comps:
if s and s[-1] != "/":
s += "/"
s += c
try:
os.mkdir(s)
ret = True
except OSError as e:
if e.args[0] != errno.EEXIST and e.args[0] != errno.EISDIR:
print(e)
ret = False
return ret
def install_tar(f, prefix):
for info in f:
#print(info)
fname = info.name
#print("fname is {}".format(fname))
#try:
#fname = fname[fname.index("/") + 1:]
#except ValueError:
#fname = ""
#print("fname is {}".format(fname))
outfname = prefix + fname
#print(outfname)
if info.type != tarfile.DIRTYPE:
print("Extracting " + outfname)
_makedirs(outfname)
subf = f.extractfile(info)
save_file(outfname, subf)
def save_file(fname, subf):
global file_buf
with open(fname, "wb") as outf:
while True:
sz = subf.readinto(file_buf)
if not sz:
break
outf.write(file_buf, sz)
outf.close()
if __name__ == "__main__":
url = kv.get('_amp_pyapp_url')
if isinstance(url, str):
install_pkg(url, "/data/pyamp/")
kv.remove('_amp_pyapp_url')
reboot()
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/fs/lib/appOta.py | Python | apache-2.0 | 3,987 |
"""
Copyright (C) 2015-2021 Alibaba Group Holding Limited
MicroPython's driver for CHT8305
Author: HaaS
Date: 2021/09/14
"""
from micropython import const
from utime import sleep_ms
from driver import I2C
CHT8305_REG_TEMP = 0x00
CHT8305_REG_HUMI = 0x01
# The register address in CHT8305 controller.
class CHT8305Error(Exception):
def __init__(self, value=0, msg="cht8305 common error"):
self.value = value
self.msg = msg
def __str__(self):
return "Error code:%d, Error message: %s" % (self.value, str(self.msg))
__repr__ = __str__
class CHT8305(object):
"""
This class implements cht8305 chip's functions.
"""
def __init__(self, i2cDev):
self._i2cDev = None
if not isinstance(i2cDev, I2C):
raise ValueError("parameter is not an I2C object")
# make CHT8305's internal object points to i2cDev
self._i2cDev = i2cDev
def getTemperature(self):
"""Get temperature."""
# make sure CHT8305's internal object is valid before I2C operation
if self._i2cDev is None:
raise ValueError("invalid I2C object")
# send temperature register to CHT8305
reg = bytearray([CHT8305_REG_TEMP])
self._i2cDev.write(reg)
# wait for 30ms
sleep_ms(30)
readData = bytearray(2)
# read temperature from CHT8305
self._i2cDev.read(readData)
# convert the temperature data to actual value
value = (readData[0] << 8) | readData[1]
if (value & 0xFFFC):
temperature = (165.0 * float(value)) / 65536.0 - 40.0
else:
raise CHT8305Error("failed to get temperature.")
return temperature
def getHumidity(self):
"""Get humidity."""
# make sure CHT8305's internal object is valid before I2C operation
if self._i2cDev is None:
raise ValueError("invalid I2C object")
# send humidity register to CHT8305
reg = bytearray([CHT8305_REG_HUMI])
self._i2cDev.write(reg)
sleep_ms(30)
# read humidity from CHT8305
readData = bytearray(2)
self._i2cDev.read(readData)
# convert the humidity data to actual value
value = (readData[0] << 8) | readData[1]
if (value & 0xFFFE):
humidity = ((125.0 * float(value)) / 65535.0) - 6.0
else:
raise CHT8305Error("failed to get humidity.")
return humidity
def getTempHumidity(self):
"""Get temperature and humidity."""
# make sure CHT8305's internal object is valid before I2C operation
if self._i2cDev is None:
raise ValueError("invalid I2C object")
temphumidity = [0, 1]
# send temperature register to CHT8305
reg = bytearray([CHT8305_REG_TEMP])
self._i2cDev.write(reg)
sleep_ms(30)
# 4 bytes means read temperature and humidity back in one read operation
readData = bytearray(4)
self._i2cDev.read(readData)
#print("rawdata %d-%d-%d-%d" %(readData[0],readData[1],readData[2],readData[3]))
# convert the temperature and humidity data to actual value
value = (readData[0] << 8) | readData[1]
if (value & 0xFFFC):
temphumidity[0] = (165.0 * float(value)) / 65536.0 - 40.0
else:
raise CHT8305Error("failed to get temperature.")
value = (readData[2] << 8) | readData[3]
if (value & 0xFFFE):
temphumidity[1] = ((125.0 * float(value)) / 65535.0) - 6.0
else:
raise CHT8305Error("failed to get humidity.")
return temphumidity
if __name__ == "__main__":
'''
The below i2c configuration is needed in your board.json.
"cht8305": {
"type": "I2C",
"port": 1,
"addrWidth": 7,
"freq": 400000,
"mode": "master",
"devAddr": 64
}
'''
print("Testing cht8305 ...")
i2cDev = I2C()
i2cDev.open("cht8305")
cht8305Dev = CHT8305(i2cDev)
temperature = cht8305Dev.getTemperature()
print("The temperature is: %f" % temperature)
humidity = cht8305Dev.getHumidity()
print("The humidity is: %f" % humidity)
i2cDev.close()
print("Test cht8305 done!")
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/fs/lib/cht8305/cht8305.py | Python | apache-2.0 | 4,277 |
"""
Copyright (C) 2015-2021 Alibaba Group Holding Limited
MicroPython's driver for CHT8305
Author: HaaS
Date: 2022/05/11
"""
import lvgl as lv
import lvgl_display
print("display_driver init")
if not lv.is_initialized():
#print("lv.init")
lv.init()
if not lvgl_display.is_initialized():
#print("lvgl_display.init")
lvgl_display.init()
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/fs/lib/display_driver/display_driver.py | Python | apache-2.0 | 369 |
"""
Copyright (C) 2015-2021 Alibaba Group Holding Limited
"""
from driver import I2C
import kv
class HAASEDUK1(object):
def __init__(self):
self.i2cDev = None
# 获取版本号
# 返回值为1，代表k1c
# 返回值为0，代表k1
def getHWID(self):
hwId = -1
result = kv.geti("HAASEDU_NAME")
if (result != None):
if (result == 1):
print("HAASEDUK1 hw version is 1.1")
return 1
elif (result == 0):
print("HAASEDUK1 hw version is 1.0")
return 0
else:
pass
# kv中不存在HAASEDU_NAME键值对，则通过外围传感器进行判断
# 读取QMI8610传感器device identifier register的值
self.i2cDev = I2C()
self.i2cDev.open("qmi8610")
buf = bytearray(1)
buf[0] = 0
self.i2cDev.memRead(buf, 0, 8) # register address:0 - FIS device identifier register address
self.i2cDev.close()
if buf[0] == 0xfc:
hwId = 1
else:
# 读取QMI8610传感器chip id register的值
self.i2cDev.open("qmp6988")
buf[0] = 0xD1 # chip id register
self.i2cDev.write(buf)
self.i2cDev.read(buf)
self.i2cDev.close()
if buf[0] == 0x5C:
hwId = 1
else:
# 读取QMC6310传感器chip id register的值
self.i2cDev.open("qmc6310")
buf[0] = 0x00 # chip id register
self.i2cDev.write(buf)
self.i2cDev.read(buf)
self.i2cDev.close()
if buf[0] == 0x80:
hwId = 1
if hwId == 1:
kv.seti("HAASEDU_NAME", 1)
print("HAASEDUK1 hw version is 1.1")
return 1
else:
kv.seti("HAASEDU_NAME", 0)
print("HAASEDUK1 hw version is 1.0")
return 0
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/fs/lib/haaseduk1/haaseduk1.py | Python | apache-2.0 | 1,984 |
"""
Copyright (C) 2015-2021 Alibaba Group Holding Limited
HaaS Python's driver for MPU6050
Author: HaaS Python Team
Date: 2022/02/02
"""
from micropython import const
from driver import I2C
from utime import sleep_ms
import math
MPU_SELF_TESTX_REG = const(0X0D) #自检寄存器X
MPU_SELF_TESTY_REG = const(0X0E) #自检寄存器Y
MPU_SELF_TESTZ_REG = const(0X0F) #自检寄存器Z
MPU_SELF_TESTA_REG = const(0X10) #自检寄存器A
MPU_SAMPLE_RATE_REG = const(0X19) #采样频率分频器
MPU_CFG_REG = const(0X1A) #配置寄存器
MPU_GYRO_CFG_REG = const(0X1B) #陀螺仪配置寄存器
MPU_ACCEL_CFG_REG = const(0X1C) #加速度计配置寄存器
MPU_MOTION_DET_REG = const(0X1F) #运动检测阀值设置寄存器
MPU_FIFO_EN_REG = const(0X23) #FIFO使能寄存器
MPU_I2CMST_CTRL_REG = const(0X24) #IIC主机控制寄存器
MPU_I2CSLV0_ADDR_REG = const(0X25) #IIC从机0器件地址寄存器
MPU_I2CSLV0_REG = const(0X26) #IIC从机0数据地址寄存器
MPU_I2CSLV0_CTRL_REG = const(0X27) #IIC从机0控制寄存器
MPU_I2CSLV1_ADDR_REG = const(0X28) #IIC从机1器件地址寄存器
MPU_I2CSLV1_REG = const(0X29) #IIC从机1数据地址寄存器
MPU_I2CSLV1_CTRL_REG = const(0X2A) #IIC从机1控制寄存器
MPU_I2CSLV2_ADDR_REG = const(0X2B) #IIC从机2器件地址寄存器
MPU_I2CSLV2_REG = const(0X2C) #IIC从机2数据地址寄存器
MPU_I2CSLV2_CTRL_REG = const(0X2D) #IIC从机2控制寄存器
MPU_I2CSLV3_ADDR_REG = const(0X2E) #IIC从机3器件地址寄存器
MPU_I2CSLV3_REG = const(0X2F) #IC从机3数据地址寄存器
MPU_I2CSLV3_CTRL_REG = const(0X30) #IIC从机3控制寄存器
MPU_I2CSLV4_ADDR_REG = const(0X31) #IIC从机4器件地址寄存器
MPU_I2CSLV4_REG = const(0X32) #IIC从机4数据地址寄存器
MPU_I2CSLV4_DO_REG = const(0X33) #IIC从机4写数据寄存器
MPU_I2CSLV4_CTRL_REG = const(0X34) #IIC从机4控制寄存器
MPU_I2CSLV4_DI_REG = const(0X35) #IIC从机4读数据寄存器
MPU_I2CMST_STA_REG = const(0X36) #IIC主机状态寄存器
MPU_INTBP_CFG_REG = const(0X37) #中断/旁路设置寄存器
MPU_INT_EN_REG = const(0X38) #中断使能寄存器
MPU_INT_STA_REG = const(0X3A) #中断状态寄存器
MPU_ACCEL_XOUTH_REG = const(0X3B) #加速度值,X轴高8位寄存器
MPU_ACCEL_XOUTL_REG = const(0X3C) #速度值,X轴低8位寄存器
MPU_ACCEL_YOUTH_REG = const(0X3D) #加速度值,Y轴高8位寄存器
MPU_ACCEL_YOUTL_REG = const(0X3E) #加速度值,Y轴低8位寄存器
MPU_ACCEL_ZOUTH_REG = const(0X3F) #加速度值,Z轴高8位寄存器
MPU_ACCEL_ZOUTL_REG = const(0X40) #加速度值,Z轴低8位寄存器
MPU_TEMP_OUTH_REG = const(0X41) #温度值高八位寄存器
MPU_TEMP_OUTL_REG = const(0X42) #温度值低8位寄存器
MPU_GYRO_XOUTH_REG = const(0X43) #陀螺仪值,X轴高8位寄存器
MPU_GYRO_XOUTL_REG = const(0X44) #陀螺仪值,X轴低8位寄存器
MPU_GYRO_YOUTH_REG = const(0X45) #陀螺仪值,Y轴高8位寄存器
MPU_GYRO_YOUTL_REG = const(0X46) #陀螺仪值,Y轴低8位寄存器
MPU_GYRO_ZOUTH_REG = const(0X47) #陀螺仪值,Z轴高8位寄存器
MPU_GYRO_ZOUTL_REG = const(0X48) #陀螺仪值,Z轴低8位寄存器
MPU_I2CSLV0_DO_REG = const(0X63) #IIC从机0数据寄存器
MPU_I2CSLV1_DO_REG = const(0X64) #IIC从机1数据寄存器
MPU_I2CSLV2_DO_REG = const(0X65) #IIC从机2数据寄存器
MPU_I2CSLV3_DO_REG = const(0X66) #IIC从机3数据寄存器
MPU_I2CMST_DELAY_REG = const(0X67) #IIC主机延时管理寄存器
MPU_SIGPATH_RST_REG = const(0X68) #信号通道复位寄存器
MPU_MDETECT_CTRL_REG = const(0X69) #运动检测控制寄存器
MPU_USER_CTRL_REG = const(0X6A) #用户控制寄存器
MPU_PWR_MGMT1_REG = const(0X6B) #电源管理寄存器1
MPU_PWR_MGMT2_REG = const(0X6C) #电源管理寄存器2
MPU_FIFO_CNTH_REG = const(0X72) #FIFO计数寄存器高八位
MPU_FIFO_CNTL_REG = const(0X73) #FIFO计数寄存器低八位
MPU_FIFO_RW_REG = const(0X74) #FIFO读写寄存器
MPU_DEVICE_ID_REG = const(0X75) #器件ID寄存器
MPU_DEV_ID = const(0x68)
mpu6050_dict = {'temp': 0.0, 'gyroX': 0, 'gyroY': 0, 'gyroZ': 0, 'accX': 0, 'accY': 0, 'accZ': 0}
class MPU6050Error(Exception):
def __init__(self, value=0, msg="mpu6050 common error"):
self.value = value
self.msg = msg
def __str__(self):
return "Error code:%d, Error message: %s" % (self.value, str(self.msg))
__repr__ = __str__
class MPU6050(object):
"""
This class implements mpu6050 chip's defs.
"""
def __init__(self, i2cDev):
self._i2cDev = None
if not isinstance(i2cDev, I2C):
raise ValueError("parameter is not an I2C object")
# make MPU6050's internal object points to i2cDev
self._i2cDev = i2cDev
# 初始化MPU6050传感器
r = self.init()
if r != 0:
raise ValueError("MPU6050 init error")
def i2c_write_byte(self, addr, value):
Reg = bytearray([addr, value])
self._i2cDev.write(Reg)
#print("--> write addr " + str(addr) + ", value = " + str(value))
def i2c_read_byte(self, addr):
Reg = bytearray([addr])
self._i2cDev.write(Reg)
tmp = bytearray(1)
self._i2cDev.read(tmp)
#print("<-- read addr " + str(addr) + ", value = " + str(tmp[0]))
return tmp[0]
def i2c_read_len(self, addr, len):
reg = bytearray([addr])
data = bytearray(len)
self._i2cDev.write(reg)
sleep_ms(20)
self._i2cDev.read(data)
# print("--> read " + str(len) + " bytes from addr " + str(addr) + ", " + str(len) + " bytes value = " + str(data))
return data
# 设置MPU6050陀螺仪传感器满量程范围
# fsr:0,±250dps;1,±500dps;2,±1000dps;3,±2000dps
# 返回值:0,设置成功
# 其他,设置失败
def setGyroFsr(self, fsr):
return self.i2c_write_byte(MPU_GYRO_CFG_REG, fsr << 3) # 设置陀螺仪满量程范围
# 设置MPU6050加速度传感器满量程范围
# fsr:0,±2g;1,±4g;2,±8g;3,±16g
# 返回值:0,设置成功
# 其他,设置失败
def setAccelFsr(self, fsr):
return self.i2c_write_byte(MPU_ACCEL_CFG_REG, fsr << 3) # 设置加速度传感器满量程范围
# 设置MPU6050的数字低通滤波器
# lpf:数字低通滤波频率(Hz)
# 返回值:0,设置成功
# 其他,设置失败
def setLPF(self, lpf):
if (lpf >= 188):
data = 1
elif (lpf >= 98):
data = 2
elif (lpf >= 42):
data = 3
elif (lpf >= 20):
data = 4
elif (lpf >= 10):
data = 5
else:
data = 6
return self.i2c_write_byte(MPU_CFG_REG, data) # 设置数字低通滤波器
# 设置MPU6050的采样率(假定Fs=1KHz)
# rate:4~1000(Hz)
# 返回值:0,设置成功
# 其他,设置失败
def setRate(self, rate):
if (rate > 1000):
rate = 1000
if (rate < 4):
rate = 4
data = 1000 // rate - 1
self.i2c_write_byte(MPU_SAMPLE_RATE_REG, data) # 设置数字低通滤波器
return self.setLPF(rate / 2) # 自动设置LPF为采样率的一半
# 得到温度值
# 返回值:温度值
def getTemperature(self):
buf = bytearray(2)
buf = self.i2c_read_len(MPU_TEMP_OUTH_REG, 2)
raw = (buf[0] << 8) | buf[1]
if (raw > (1 << 15)):
raw = raw - (1<<16)
temp = 36.53 + (raw) / 340
return round(temp, 2)
# 得到陀螺仪值(原始值)
# gx,gy,gz:陀螺仪x,y,z轴的原始读数(带符号)
# 返回值:0,成功
# 其他,错误代码
def getGyroscope(self):
buf = bytearray(6)
buf = self.i2c_read_len(MPU_GYRO_XOUTH_REG, 6)
gx = (buf[0] << 8) | buf[1]
gy = (buf[2] << 8) | buf[3]
gz = (buf[4] << 8) | buf[5]
if (gx > (1 << 15)):
gx = gx - (1<<16)
if (gy > (1 << 15)):
gy = gy - (1<<16)
if (gz > (1 << 15)):
gz = gz - (1<<16)
return (gx, gy, gz)
# 得到加速度值(原始值)
# gx,gy,gz:陀螺仪x,y,z轴的原始读数(带符号)
# 返回值:0,成功
# 其他,错误代码
def getAcceleration(self):
buf = bytearray(6)
buf = self.i2c_read_len(MPU_ACCEL_XOUTH_REG, 6)
ax = (buf[0] << 8) | buf[1]
ay = (buf[2] << 8) | buf[3]
az = (buf[4] << 8) | buf[5]
if (ax > (1 << 15)):
ax = ax - (1<<16)
if (ay > (1 << 15)):
ay = ay - (1<<16)
if (az > (1 << 15)) :
az = az - (1<<16)
return (ax, ay, az)
def getData(self):
global mpu6050_dict
mpu6050_dict['temp'] = self.getTemperature()
arr = self.getGyroscope()
mpu6050_dict['gyroX'] = arr[0]
mpu6050_dict['gyroY'] = arr[1]
mpu6050_dict['gyroZ'] = arr[2]
brr = self.getAcceleration()
mpu6050_dict['accX'] = brr[0]
mpu6050_dict['accY'] = brr[1]
mpu6050_dict['accZ'] = brr[2]
return mpu6050_dict
# 初始化MPU6050
# 返回值:0,成功
# 其他,错误代码
def init(self):
device_id = 0
self.i2c_write_byte(MPU_PWR_MGMT1_REG, 0X80) # 复位MPU6050
sleep_ms(200)
self.i2c_write_byte(MPU_PWR_MGMT1_REG, 0X00) # 唤醒MPU6050
self.setGyroFsr(3) # 陀螺仪传感器,±2000dps
self.setAccelFsr(0) # 加速度传感器,±2g
self.setRate(50) # 设置采样率50Hz
self.i2c_write_byte(MPU_INT_EN_REG, 0X00) # 关闭所有中断
self.i2c_write_byte(MPU_USER_CTRL_REG, 0X00) # I2C主模式关闭
self.i2c_write_byte(MPU_FIFO_EN_REG, 0X00) # 关闭FIFO
self.i2c_write_byte(MPU_INTBP_CFG_REG, 0X80) # INT引脚低电平有效
device_id = self.i2c_read_byte(MPU_DEVICE_ID_REG)
if (device_id == MPU_DEV_ID):
# 器件ID正确
self.i2c_write_byte(MPU_PWR_MGMT1_REG, 0X01) # 设置CLKSEL,PLL X轴为参考
self.i2c_write_byte(MPU_PWR_MGMT2_REG, 0X00) # 加速度与陀螺仪都工作
self.setRate(50) # 设置采样率为50Hz
return 0
else:
return 1
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/fs/lib/mpu6050/mpu6050.py | Python | apache-2.0 | 10,409 |
"""
Copyright (C) 2015-2021 Alibaba Group Holding Limited
MicroPython's driver for QMC5883l
Author: HaaS
Date: 2021/09/09
"""
from driver import I2C
from utime import sleep_ms
import math
x_max = 0
x_min = 0
z_min = 0
y_max = 0
y_min = 0
z_max = 0
addr = 0
mode = 0
rate = 0
g_range = 0
oversampling = 0
INT16_MIN = (-32767-1)
INT16_MAX = 32767
# Register numbers
QMC5883L_X_LSB = 0
QMC5883L_X_MSB = 1
QMC5883L_Y_LSB = 2
QMC5883L_Y_MSB = 3
QMC5883L_Z_LSB = 4
QMC5883L_Z_MSB = 5
QMC5883L_STATUS = 6
QMC5883L_TEMP_LSB = 7
QMC5883L_TEMP_MSB = 8
QMC5883L_CONFIG = 9
QMC5883L_CONFIG2 = 10
QMC5883L_RESET = 11
QMC5883L_RESERVED = 12
QMC5883L_CHIP_ID = 13
QMC5883L_STATUS_DRDY = 1
QMC5883L_STATUS_OVL = 2
QMC5883L_STATUS_DOR = 4
# Oversampling values for the CONFIG register
QMC5883L_CONFIG_OS512 = 0b00000000
QMC5883L_CONFIG_OS256 = 0b01000000
QMC5883L_CONFIG_OS128 = 0b10000000
QMC5883L_CONFIG_OS64 = 0b11000000
# Range values for the CONFIG register
QMC5883L_CONFIG_2GAUSS = 0b00000000
QMC5883L_CONFIG_8GAUSS = 0b00010000
# Rate values for the CONFIG register
QMC5883L_CONFIG_10HZ = 0b00000000
QMC5883L_CONFIG_50HZ = 0b00000100
QMC5883L_CONFIG_100HZ = 0b00001000
QMC5883L_CONFIG_200HZ = 0b00001100
# Mode values for the CONFIG register
QMC5883L_CONFIG_STANDBY = 0b00000000
QMC5883L_CONFIG_CONT = 0b00000001
# Apparently M_PI isn't available in all environments.
M_PI = 3.14159265358979323846264338327950288
class QMC5883(object):
"""
This class implements qmc5883 chip's defs.
"""
def __init__(self, i2cDev):
self._i2cDev = None
if not isinstance(i2cDev, I2C):
raise ValueError("parameter is not an I2C object")
# make QMC5883's internal object points to i2cDev
self._i2cDev = i2cDev
# 初始化QMC5883传感器
self._devInit()
def devRegRead1Byte(self, addr):
return self.devRegReadWrite1Byte(0, addr, 0)
def devRegReadWrite1Byte(self, mode, addr, value):
#0 read mode
#1 write mode
if (mode == 0):
Reg = bytearray([addr])
self._i2cDev.write(Reg)
sleep_ms(30)
tmp = bytearray(1)
self._i2cDev.read(tmp)
#print("<-- read addr " + str(addr) + ", value = " + str(tmp[0]))
return tmp[0]
else:
Reg = bytearray([addr, value])
self._i2cDev.write(Reg)
#print("--> write addr " + str(addr) + ", value = " + str(value))
return 0
def devRegWrite1Byte(self, data):
Reg = bytearray([data])
self._i2cDev.write(Reg)
#print("--> write value = " + str(Reg[0]))
def devRegReadNByte(self, addr, len):
reg = bytearray([addr])
data = bytearray(len)
self._i2cDev.write(reg)
sleep_ms(20)
self._i2cDev.read(data)
#print("--> read " + str(len) + " bytes from addr " + str(addr) + ", " + str(len) + " bytes value = " + str(data))
return data
def _WriteRegister(self, addr, reg, data):
#print(">>>> wirte reg: %d, data: %d\n" %(reg, data))
self.devRegReadWrite1Byte(1, reg, data)
def _ReadRegister(self, reg):
return self.devRegRead1Byte(reg)
def _ReadLen(self, reg, len):
return self.devRegReadNByte(reg, len)
def _reconfig(self):
self._WriteRegister(addr, QMC5883L_CONFIG, oversampling | g_range | rate | mode)
sleep_ms(50)
self._WriteRegister(addr, QMC5883L_CONFIG2, 0x1)
def _reset(self):
self._WriteRegister(addr, QMC5883L_RESET, 0x01)
sleep_ms(500)
self._reconfig()
sleep_ms(50)
self._resetCalibration()
def _setOverSampling(self, x):
global oversampling
if (x == 512):
oversampling = QMC5883L_CONFIG_OS512
elif (x == 256):
oversampling = QMC5883L_CONFIG_OS256
elif (x == 128):
oversampling = QMC5883L_CONFIG_OS128
elif (x == 64):
oversampling = QMC5883L_CONFIG_OS64
self._reconfig()
def _setRange(self, x):
global g_range
if (x == 2):
g_range = QMC5883L_CONFIG_2GAUSS
elif (x == 8):
g_range = QMC5883L_CONFIG_8GAUSS
self._reconfig()
def _setSamplingRate(self, x):
global rate
if (x == 10):
rate = QMC5883L_CONFIG_10HZ
elif (x == 50):
rate = QMC5883L_CONFIG_50HZ
elif (x == 100):
rate = QMC5883L_CONFIG_100HZ
elif (x == 200):
rate = QMC5883L_CONFIG_200HZ
self._reconfig()
def _devInit(self):
global addr
global oversampling
global g_range
global rate
global mode
# This assumes the wire library has been initialized.
oversampling = QMC5883L_CONFIG_OS512
g_range = QMC5883L_CONFIG_8GAUSS
rate = QMC5883L_CONFIG_200HZ
mode = QMC5883L_CONFIG_CONT
#print("addr %d,oversampling %d,g_range %d,rate %d, mode %d" %(addr, oversampling, g_range, rate, mode))
self._reset()
def _devReady(self):
sleep_ms(200)
tmp = self._ReadRegister(QMC5883L_STATUS) & QMC5883L_STATUS_DRDY
return tmp
def _ReadRaw(self):
timeout = 10000
arr = [1, 2, 3]
data = bytearray(6)
ready = self._devReady()
while (ready == 0 and timeout):
ready = self._devReady()
timeout -= 1
#print("ready = %d" %(ready))
data = self._ReadLen(QMC5883L_X_LSB, 6)
x = data[0] | (data[1] << 8)
y = data[2] | (data[3] << 8)
z = data[4] | (data[5] << 8)
#print("read_raw[%f,%f,%f],\n" %(x ,y, z))
if (x > (1 << 15)):
x = x - (1<<16)
if (y > (1 << 15)):
y = y - (1<<16)
if (z > (1 << 15)):
z = z - (1<<16)
arr[0] = x
arr[1] = y
arr[2] = z
return arr
def _resetCalibration(self):
global x_max
global x_min
global z_min
global y_max
global y_min
global z_max
x_max = y_max = z_max = INT16_MIN
x_min = y_min = z_min = INT16_MAX
def getHeading(self):
global x_max
global x_min
global z_min
global y_max
global y_min
global z_max
global addr
global mode
global rate
global g_range
global oversampling
tmp = self._ReadRegister(QMC5883L_STATUS) & QMC5883L_STATUS_DRDY
#print("read QMC5883L_STATUS: %d\n" %(tmp))
xyz_org = self._ReadRaw()
x_org = xyz_org[0]
y_org = xyz_org[1]
z_org = xyz_org[2]
#print("org[%f,%f,%f]\n" %(x_org ,y_org, z_org))
# Update the observed boundaries of the measurements
if (x_org < x_min):
x_min = x_org
if (x_org > x_max):
x_max = x_org
if (y_org < y_min):
y_min = y_org
if (y_org > y_max):
y_max = y_org
if (z_org < z_min):
z_min = z_org
if (z_org > z_max):
z_max = z_org
# Bail out if not enough data is available.
if ((x_min == x_max) or (y_min == y_max) or (z_max == z_min)):
#print("x_min %f == x_max %f or y_min %f == y_max %f or z_max%f == z_min%f\n" %(x_min, x_max, y_min, y_max, z_max, z_min))
return 0
# Recenter the measurement by subtracting the average
x_offset = (x_max + x_min) / 2.0
y_offset = (y_max + y_min) / 2.0
z_offset = (z_max + z_min) / 2.0
x_fit = (x_org - x_offset) * 1000.0 / (x_max - x_min)
y_fit = (y_org - y_offset) * 1000.0 / (y_max - y_min)
z_fit = (z_org - z_offset) * 1000.0 / (z_max - z_min)
#print("fix[%f,%f,%f],\n" %(x_fit ,y_fit, z_fit))
heading = 180.0 * math.atan2(x_fit, y_fit) / M_PI
if (heading <= 0):
heading = heading + 360
#print("heading = %f\n", heading)
return heading
if __name__ == "__main__":
'''
The below i2c configuration is needed in your board.json.
"qmc5883": {
"type": "I2C",
"port": 1,
"addrWidth": 7,
"freq": 400000,
"mode": "master",
"devAddr": 13
}
'''
print("Testing qmc5883 ...")
i2cDev = I2C()
i2cDev.open("qmc5883")
qmc5883Dev = QMC5883(i2cDev)
h = qmc5883Dev.getHeading()
print("The heading data is:", h)
i2cDev.close()
del qmc5883Dev
print("Test qmc5883 done!")
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/fs/lib/qmc5883/qmc5883.py | Python | apache-2.0 | 8,658 |
"""
Copyright (C) 2015-2021 Alibaba Group Holding Limited
MicroPython's driver for QMI8610
Author: HaaS
Date: 2021/09/14
"""
from micropython import const
from driver import I2C
from utime import sleep_ms
import math
M_PI = (3.14159265358979323846)
ONE_G = (9.80665)
FISIMU_STATUS1_CMD_DONE = const(0x01)
FISIMU_STATUS1_WAKEUP_EVENT = const(0x04)
FISIMU_CTRL7_DISABLE_ALL = const(0x0)
FISIMU_CTRL7_ACC_ENABLE = const(0x1)
FISIMU_CTRL7_GYR_ENABLE = const(0x2)
FISIMU_CTRL7_MAG_ENABLE = const(0x4)
FISIMU_CTRL7_AE_ENABLE = const(0x8)
FISIMU_CTRL7_ENABLE_MASK = const(0xF)
FISIMU_CONFIG_ACC_ENABLE = FISIMU_CTRL7_ACC_ENABLE
FISIMU_CONFIG_GYR_ENABLE = FISIMU_CTRL7_GYR_ENABLE
FISIMU_CONFIG_MAG_ENABLE = FISIMU_CTRL7_MAG_ENABLE
FISIMU_CONFIG_AE_ENABLE = FISIMU_CTRL7_AE_ENABLE
FISIMU_CONFIG_ACCGYR_ENABLE = (FISIMU_CONFIG_ACC_ENABLE | FISIMU_CONFIG_GYR_ENABLE)
FISIMU_CONFIG_ACCGYRMAG_ENABLE = (FISIMU_CONFIG_ACC_ENABLE | FISIMU_CONFIG_GYR_ENABLE | FISIMU_CONFIG_MAG_ENABLE)
FISIMU_CONFIG_AEMAG_ENABLE = (FISIMU_CONFIG_AE_ENABLE | FISIMU_CONFIG_MAG_ENABLE)
FisRegister_WhoAmI = const(0) # FIS device identifier register.
FisRegister_Revision = const(1) # FIS hardware revision register.
FisRegister_Ctrl1 = const(2) # General and power management modes.
FisRegister_Ctrl2 = const(3) # Accelerometer control. *
FisRegister_Ctrl3 = const(4) # Gyroscope control.
FisRegister_Ctrl4 = const(5) # Magnetometer control.
FisRegister_Ctrl5 = const(6) # Data processing settings.
FisRegister_Ctrl6 = const(7) # AttitudeEngine control.
FisRegister_Ctrl7 = const(8) # Sensor enabled status.
FisRegister_Ctrl8 = const(9) # Reserved - do not write.
FisRegister_Ctrl9 = const(10) # Host command register.
FisRegister_Cal1_L = const(11) # Calibration register 1 least significant byte.
FisRegister_Cal1_H = const(12) # Calibration register 1 most significant byte.
FisRegister_Cal2_L = const(13) # Calibration register 2 least significant byte.
FisRegister_Cal2_H = const(14) # Calibration register 2 most significant byte.
FisRegister_Cal3_L = const(15) # Calibration register 3 least significant byte.
FisRegister_Cal3_H = const(16) # Calibration register 3 most significant byte.
FisRegister_Cal4_L = const(17) # Calibration register 4 least significant byte.
FisRegister_Cal4_H = const(18) # Calibration register 4 most significant byte.
FisRegister_FifoCtrl = const(19) # FIFO control register.
FisRegister_FifoData = const(20) # FIFO data register.
FisRegister_FifoStatus = const(21) # FIFO status register.
FisRegister_Status0 = const(22) # Output data overrun and availability.
FisRegister_Status1 = const(23) # Miscellaneous status register.
FisRegister_CountOut = const(24) # Sample counter.
FisRegister_Ax_L = const(25) # Accelerometer X axis least significant byte.
FisRegister_Ax_H = const(26) # Accelerometer X axis most significant byte.
FisRegister_Ay_L = const(27) # Accelerometer Y axis least significant byte.
FisRegister_Ay_H = const(28) # Accelerometer Y axis most significant byte.
FisRegister_Az_L = const(29) # Accelerometer Z axis least significant byte.
FisRegister_Az_H = const(30) # Accelerometer Z axis most significant byte.
FisRegister_Gx_L = const(31) # Gyroscope X axis least significant byte.
FisRegister_Gx_H = const(32) # Gyroscope X axis most significant byte.
FisRegister_Gy_L = const(33) # Gyroscope Y axis least significant byte.
FisRegister_Gy_H = const(34) # Gyroscope Y axis most significant byte.
FisRegister_Gz_L = const(35) # Gyroscope Z axis least significant byte.
FisRegister_Gz_H = const(36) # Gyroscope Z axis most significant byte.
FisRegister_Mx_L = const(37) # Magnetometer X axis least significant byte.
FisRegister_Mx_H = const(38) # Magnetometer X axis most significant byte.
FisRegister_My_L = const(39) # Magnetometer Y axis least significant byte.
FisRegister_My_H = const(40) # Magnetometer Y axis most significant byte.
FisRegister_Mz_L = const(41) # Magnetometer Z axis least significant byte.
FisRegister_Mz_H = const(42) # Magnetometer Z axis most significant byte.
FisRegister_Q1_L = const(43) # Quaternion increment W least significant byte.
FisRegister_Q1_H = const(44) # Quaternion increment W most significant byte.
FisRegister_Q2_L = const(45) # Quaternion increment X least significant byte.
FisRegister_Q2_H = const(46) # Quaternion increment X most significant byte.
FisRegister_Q3_L = const(47) # Quaternion increment Y least significant byte.
FisRegister_Q3_H = const(48) # Quaternion increment Y most significant byte.
FisRegister_Q4_L = const(49) # Quaternion increment Z least significant byte.
FisRegister_Q4_H = const(50) # Quaternion increment Z most significant byte.
FisRegister_Dvx_L = const(51) # Velocity increment X least significant byte.
FisRegister_Dvx_H = const(52) # Velocity increment X most significant byte.
FisRegister_Dvy_L = const(53) # Velocity increment Y least significant byte.
FisRegister_Dvy_H = const(54) # Velocity increment Y most significant byte.
FisRegister_Dvz_L = const(55) # Velocity increment Z least significant byte.
FisRegister_Dvz_H = const(56) # Velocity increment Z most significant byte.
FisRegister_Temperature = const(57) # Temperature output.
FisRegister_AeClipping = const(58) # AttitudeEngine clipping flags.
FisRegister_AeOverflow = const(59) # AttitudeEngine overflow flags.
Ctrl9_Nop = const(0) # No operation.
Ctrl9_ResetFifo = const(0x2) # Reset FIFO.
Ctrl9_SetMagXCalibration = const(0x6) # Set magnetometer X calibration values.
Ctrl9_SetMagYCalibration = const(0x7) # Set magnetometer Y calibration values.
Ctrl9_SetMagZCalibration = const(0x8) # Set magnetometer Z calibration values.
Ctrl9_SetAccelOffset = const(0x12) # Set accelerometer offset correction value.
Ctrl9_SetGyroOffset = const(0x13) # Set gyroscope offset correction value.
Ctrl9_SetAccelSensitivity = const(0x14) # Set accelerometer sensitivity.
Ctrl9_SetGyroSensitivity = const(0x15) # Set gyroscope sensitivity.
Ctrl9_UpdateMagBias = const(0xB) # Update magnemoter bias compensation.
Ctrl9_TriggerMotionOnDemand = const(0x0c) # Trigger motion on demand sample.
Ctrl9_UpdateAttitudeEngineGyroBias = const(0xE) # Update gyroscope bias compensation.
Ctrl9_ReadTrimmedFrequencyValue = const(0x18) # Read frequency correction value.
Ctrl9_ReadFifo = const(0x0D) # Prepare for FIFO read sequence.
Ctrl9_ConfigureWakeOnMotion = const(0x19) # Set wake on motion parameters.
Lpf_Disable = const(0) # Disable low pass filter.
Lpf_Enable = const(1) # Enable low pass filter.
Hpf_Disable = const(0) # Disable high pass filter.
Hpf_Enable = const(1) # Enable high pass filter.
AccRange_2g = const(0 << 3) # +/- 2g range
AccRange_4g = const(1 << 3) # +/- 4g range
AccRange_8g = const(2 << 3) # +/- 8g range
AccRange_16g = const(3 << 3) # +/- 16g range
AccOdr_1024Hz = const(0) # High resolution 1024Hz output rate.
AccOdr_256Hz = const(1) # High resolution 256Hz output rate.
AccOdr_128Hz = const(2) # High resolution 128Hz output rate.
AccOdr_32Hz = const(3) # High resolution 32Hz output rate.
AccOdr_LowPower_128Hz = const(4) # Low power 128Hz output rate.
AccOdr_LowPower_64Hz = const(5) # Low power 64Hz output rate.
AccOdr_LowPower_25Hz = const(6) # Low power 25Hz output rate.
AccOdr_LowPower_3Hz = const(7) # Low power 3Hz output rate.
GyrRange_32dps = const(0 << 3) # +-32 degrees per second.
GyrRange_64dps = const(1 << 3) # +-64 degrees per second.
GyrRange_128dps = const(2 << 3) # +-128 degrees per second.
GyrRange_256dps = const(3 << 3) # +-256 degrees per second.
GyrRange_512dps = const(4 << 3) # +-512 degrees per second.
GyrRange_1024dps = const(5 << 3) # +-1024 degrees per second.
GyrRange_2048dps = const(6 << 3) # +-2048 degrees per second.
GyrRange_2560dps = const(7 << 3) # +-2560 degrees per second.
"""
Gyroscope output rate configuration.
"""
GyrOdr_1024Hz = const(0) # High resolution 1024Hz output rate.
GyrOdr_256Hz = const(1) # High resolution 256Hz output rate.
GyrOdr_128Hz = const(2) # High resolution 128Hz output rate.
GyrOdr_32Hz = const(3) # High resolution 32Hz output rate.
GyrOdr_OIS_8192Hz = const(6) # OIS Mode 8192Hz output rate.
GyrOdr_OIS_LL_8192Hz = const(7) # OIS LL Mode 8192Hz output rate.
AeOdr_1Hz = const(0) # 1Hz output rate.
AeOdr_2Hz = const(1) # 2Hz output rate.
AeOdr_4Hz = const(2) # 4Hz output rate.
AeOdr_8Hz = const(3) # 8Hz output rate.
AeOdr_16Hz = const(4) # 16Hz output rate.
AeOdr_32Hz = const(5) # 32Hz output rate.
AeOdr_64Hz = const(6) # 64Hz output rate.
"""
* Motion on demand mode.
*
* In motion on demand mode the application can trigger AttitudeEngine
* output samples as necessary. This allows the AttitudeEngine to be
* synchronized with external data sources.
*
* When in Motion on Demand mode the application should request new data
* by calling the FisImu_requestAttitudeEngineData() function. The
* AttitudeEngine will respond with a data ready event (INT2) when the
* data is available to be read.
"""
AeOdr_motionOnDemand = const(128) # 128Hz output rate.
MagOdr_32Hz = const(2) # 32Hz output rate.
MagDev_AK8975 = const(0 << 4) # AKM AK8975.
MagDev_AK8963 = const(1 << 4) # AKM AK8963.
AccUnit_g = const(0) # Accelerometer output in terms of g (9.81m/s^2).
AccUnit_ms2 = const(1) # Accelerometer output in terms of m/s^2.
GyrUnit_dps = const(0) # Gyroscope output in degrees/s.
GyrUnit_rads = const(1) # Gyroscope output in rad/s.
AXIS_X = const(0)
AXIS_Y = const(1)
AXIS_Z = const(2)
AXIS_TOTAL = const(4)
# FIS INT1 line.
Fis_Int1 = const(0 << 6)
# FIS INT2 line.
Fis_Int2 = const(1 << 6)
InterruptInitialState_high = const(1 << 7) # Interrupt high.
InterruptInitialState_low = const(0 << 7) # Interrupt low.
WomThreshold_high = const(128) # High threshold - large motion needed to wake.
WomThreshold_low = const(32) # Low threshold - small motion needed to wake.
acc_lsb_div = 0
gyro_lsb_div = 0
qmi8610_dict = {'temp': 0.0, 'gyroX': 0.0, 'gyroY': 0.0, 'gyroZ': 0.0, 'accX': 0.0, 'accY': 0.0, 'accZ': 0.0}
class QMI8610(object):
"""
This class implements QMI8610 chip's defs.
"""
def __init__(self, i2cDev):
self._i2cDev = None
if not isinstance(i2cDev, I2C):
raise ValueError("parameter is not an I2C object")
# make QMI8610's internal object points to i2cDev
self._i2cDev = i2cDev
# 初始化QMI8610传感器
r = self.init()
if r == 0:
raise ValueError("QMI8610 init error")
def int16(self, dat):
if dat > (1 << 15):
return dat - (1 << 16)
else:
return dat
def int32(self, dat):
if dat > (1 << 31):
return dat - (1 << 32)
else:
return dat
#写寄存器
def writeReg(self, addr, value):
Reg = bytearray([addr, value])
self._i2cDev.write(Reg)
#print("--> write addr " + str(addr) + ", value = " + str(value))
#写多个寄存器
def writeRegs(self, addr, value, len):
Regs = bytearray(value)
if (len != Regs.count):
return "Error code:%d, Error message: %s" % (self, str(self.msg))
self.writeReg(addr,Regs)
#print("--> write addr " + str(addr) + ", value = " + str(Regs))
#读寄存器
def readReg(self, addr, len):
reg = bytearray([addr])
data = bytearray(len)
self._i2cDev.memRead(data, addr, 8)
#print("--> read " + str(len) + " bytes from addr " + str(addr) + ", " + str(len) + " bytes value = " + str(data))
return data
# 设置layout
def setLayout(self, layout):
sign = [1,2,3]
map = [1,2,3]
if (layout == 0):
sign[AXIS_X] = 1
sign[AXIS_Y] = 1
sign[AXIS_Z] = 1
map[AXIS_X] = AXIS_X
map[AXIS_Y] = AXIS_Y
map[AXIS_Z] = AXIS_Z
elif (layout == 1):
sign[AXIS_X] = -1
sign[AXIS_Y] = 1
sign[AXIS_Z] = 1
map[AXIS_X] = AXIS_Y
map[AXIS_Y] = AXIS_X
map[AXIS_Z] = AXIS_Z
elif (layout == 2):
sign[AXIS_X] = -1
sign[AXIS_Y] = -1
sign[AXIS_Z] = 1
map[AXIS_X] = AXIS_X
map[AXIS_Y] = AXIS_Y
map[AXIS_Z] = AXIS_Z
elif (layout == 3):
sign[AXIS_X] = 1
sign[AXIS_Y] = -1
sign[AXIS_Z] = 1
map[AXIS_X] = AXIS_Y
map[AXIS_Y] = AXIS_X
map[AXIS_Z] = AXIS_Z
elif (layout == 4):
sign[AXIS_X] = -1
sign[AXIS_Y] = 1
sign[AXIS_Z] = -1
map[AXIS_X] = AXIS_X
map[AXIS_Y] = AXIS_Y
map[AXIS_Z] = AXIS_Z
elif (layout == 5):
sign[AXIS_X] = 1
sign[AXIS_Y] = 1
sign[AXIS_Z] = -1
map[AXIS_X] = AXIS_Y
map[AXIS_Y] = AXIS_X
map[AXIS_Z] = AXIS_Z
elif (layout == 6):
sign[AXIS_X] = 1
sign[AXIS_Y] = -1
sign[AXIS_Z] = -1
map[AXIS_X] = AXIS_X
map[AXIS_Y] = AXIS_Y
map[AXIS_Z] = AXIS_Z
elif (layout == 7):
sign[AXIS_X] = 1
sign[AXIS_Y] = 1
sign[AXIS_Z] = 1
map[AXIS_X] = AXIS_X
map[AXIS_Y] = AXIS_Y
map[AXIS_Z] = AXIS_Z
def configACC(self, range, odr, lpfEnable, hpfEnable):
ctl_dada = 0
range_set = 0
global acc_lsb_div
if (range == AccRange_2g):
range_set = 0 << 3
acc_lsb_div = (1 << 14)
elif (range == AccRange_4g):
range_set = 1 << 3
acc_lsb_div = (1 << 13)
elif (range == AccRange_8g):
range_set = 2 << 3
acc_lsb_div = (1 << 12)
else:
range_set = 2 << 3
acc_lsb_div = (1 << 12)
ctl_dada = range_set | odr
self.writeReg(FisRegister_Ctrl2, ctl_dada)
# set LPF & HPF
ctl_dada = self.readReg(FisRegister_Ctrl5, 1)[0]
ctl_dada &= 0xfc
if (lpfEnable == Lpf_Enable):
ctl_dada |= 0x02
if (hpfEnable == Hpf_Enable):
ctl_dada |= 0x01
self.writeReg(FisRegister_Ctrl5, ctl_dada)
def configGyro(self, range, odr, lpfEnable, hpfEnable):
# Set the CTRL3 register to configure dynamic range and ODR
global gyro_lsb_div
ctl_dada = range | odr
self.writeReg(FisRegister_Ctrl3, ctl_dada)
# Store the scale factor for use when processing raw data
if (range == GyrRange_32dps):
gyro_lsb_div = 1024
elif (range == GyrRange_64dps):
gyro_lsb_div = 512
elif (range == GyrRange_128dps):
gyro_lsb_div = 256
elif (range == GyrRange_256dps):
gyro_lsb_div = 128
elif (range == GyrRange_512dps):
gyro_lsb_div = 64
elif (range == GyrRange_1024dps):
gyro_lsb_div = 32
elif (range == GyrRange_2048dps):
gyro_lsb_div = 16
elif (range == GyrRange_2560dps):
#gyro_lsb_div = 8
pass
else:
gyro_lsb_div = 32
# Conversion from degrees/s to rad/s if necessary
# set LPF & HPF
ctl_dada = self.readReg(FisRegister_Ctrl5, 1)[0]
ctl_dada &= 0xf3
if (lpfEnable == Lpf_Enable):
ctl_dada |= 0x08
if (hpfEnable == Hpf_Enable):
ctl_dada |= 0x04
self.writeReg(FisRegister_Ctrl5, ctl_dada)
def configAe(self, odr):
# Configure Accelerometer and Gyroscope settings
self.configACC(AccRange_8g, AccOdr_1024Hz, Lpf_Enable, Hpf_Disable)
self.configGyro(GyrRange_2048dps, GyrOdr_1024Hz, Lpf_Enable, Hpf_Disable)
self.writeReg(FisRegister_Ctrl5, odr)
def readStatus0(self):
status = self.readReg(FisRegister_Status0, 1)[0]
return status
def readStatus1(self):
status = self.readReg(FisRegister_Status1, 1)[0]
return status
# 读取xyz的值
def readXyz(self):
buf_reg = bytearray(12)
raw_acc_xyz = [1, 2, 3]
raw_gyro_xyz = [1, 2, 3]
xyz_t = [1, 2, 3, 4, 5, 6]
buf_reg = self.readReg(FisRegister_Ax_L | 0x80, 12)
raw_acc_xyz[0] = self.int16((buf_reg[1] << 8) | (buf_reg[0]))
raw_acc_xyz[1] = self.int16((buf_reg[3] << 8) | (buf_reg[2]))
raw_acc_xyz[2] = self.int16((buf_reg[5] << 8) | (buf_reg[4]))
raw_gyro_xyz[0] = self.int16((buf_reg[7] << 8) | (buf_reg[6]))
raw_gyro_xyz[1] = self.int16((buf_reg[9] << 8) | (buf_reg[8]))
raw_gyro_xyz[2] = self.int16((buf_reg[11] << 8) | (buf_reg[10]))
# m/s2
xyz_t[0] = (raw_acc_xyz[0] * ONE_G) / acc_lsb_div
xyz_t[1] = (raw_acc_xyz[1] * ONE_G) / acc_lsb_div
xyz_t[2] = (raw_acc_xyz[2] * ONE_G) / acc_lsb_div
xyz_t[0] = -xyz_t[0]
xyz_t[1] = -xyz_t[1]
xyz_t[2] = -xyz_t[2]
# rad/s
xyz_t[3] = (raw_gyro_xyz[0] * M_PI / 180) / gyro_lsb_div
xyz_t[4] = (raw_gyro_xyz[1] * M_PI / 180) / gyro_lsb_div
xyz_t[5] = (raw_gyro_xyz[2] * M_PI / 180) / gyro_lsb_div
xyz_t[3] = xyz_t[3]
xyz_t[4] = xyz_t[4]
xyz_t[5] = -xyz_t[5]
return xyz_t
def applyScaleFactor(self, scaleFactor, nElements, rawData, calibratedData):
for i in range(nElements):
calibratedData[i] = (scaleFactor * rawData[2 * i]) | (rawData[2 * i + 1] << 8)
def processAccelerometerData(self, rawData, calibratedData):
self.applyScaleFactor(ONE_G/acc_lsb_div, 3, rawData, calibratedData)
def processGyroscopeData(self, rawData, calibratedData):
self.applyScaleFactor(M_PI / (gyro_lsb_div * 180), 3, rawData, calibratedData)
def readRawsample(self, rawData, calibratedData):
self.applyScaleFactor(M_PI / (gyro_lsb_div * 180), 3, rawData, calibratedData)
def writeCalibrationVectorBuffer(self, calVector, conversionFactor, fractionalBits):
o = 0
calCmd = bytearray(6)
for i in range(3):
o = round(calVector[i] * conversionFactor * (1 << fractionalBits))
calCmd[(2 * i)] = o & 0xFF
calCmd[(2 * i) + 1] = o >> 8
self.writeRegs(FisRegister_Cal1_L, calCmd, 6)
def doCtrl9Command(self, cmd):
gyroConfig = 0
oisModeBits = const(0x06)
oisEnabled = 0
status = 0
count = 0
gyroConfig = self.readReg(FisRegister_Ctrl3, 1)[0]
oisEnabled = ((gyroConfig & oisModeBits) == oisModeBits)
if (oisEnabled):
self.writeReg(FisRegister_Ctrl3, (gyroConfig & ~oisModeBits))
self.writeReg(FisRegister_Ctrl9, cmd)
# Check that command has been executed
while (((status & FISIMU_STATUS1_CMD_DONE) == 0) and (count < 10000)):
status = self.readReg(FisRegister_Status1, 1)[0]
count += 1
if (oisEnabled):
# Re-enable OIS mode configuration if necessary
self.writeReg(FisRegister_Ctrl3, gyroConfig)
def applyAccelerometerOffset(self, offset, unit):
if (unit == AccUnit_ms2):
conversionFactor = 1 / ONE_G
else:
conversionFactor = 1
self.writeCalibrationVectorBuffer(offset, conversionFactor, 11)
self.doCtrl9Command(Ctrl9_SetAccelOffset)
def applyGyroscopeOffset(self, offset, unit):
if (unit == GyrUnit_rads):
conversionFactor = 180 / M_PI
else:
conversionFactor = 1
self.writeCalibrationVectorBuffer(offset, conversionFactor, 6)
self.doCtrl9Command(Ctrl9_SetGyroOffset)
def applyOffsetCalibration(self, accUnit, accOffset, gyrUnit, gyrOffset):
self.applyAccelerometerOffset(accOffset, accUnit)
self.applyGyroscopeOffset(gyrOffset, gyrUnit)
# for XKF3
def enableWakeOnMotion(self):
womCmd = bytearray[3]
interrupt = Fis_Int1
initialState = InterruptInitialState_low
threshold = WomThreshold_low
blankingTime = 0x00
blankingTimeMask = 0x3F
self.enableSensors(FISIMU_CTRL7_DISABLE_ALL)
self.configACC(AccRange_2g, AccOdr_LowPower_25Hz, Lpf_Disable, Hpf_Disable)
womCmd[0] = FisRegister_Cal1_L # WoM Threshold: absolute value in mg (with 1mg/LSB resolution)
womCmd[1] = threshold
womCmd[2] = interrupt | initialState | (blankingTime & blankingTimeMask)
self.writeReg(FisRegister_Cal1_L, womCmd[1])
self.writeReg(FisRegister_Cal1_H, womCmd[2])
self.doCtrl9Command(Ctrl9_ConfigureWakeOnMotion)
self.enableSensors(FISIMU_CTRL7_ACC_ENABLE)
def disableWakeOnMotion(self):
self.enableSensors(FISIMU_CTRL7_DISABLE_ALL)
self.writeReg(FisRegister_Cal1_L, 0)
self.doCtrl9Command(Ctrl9_ConfigureWakeOnMotion)
def enableSensors(self, enableFlags):
if (enableFlags & FISIMU_CONFIG_AE_ENABLE):
enableFlags |= FISIMU_CTRL7_ACC_ENABLE | FISIMU_CTRL7_GYR_ENABLE
self.writeReg(FisRegister_Ctrl7, enableFlags & FISIMU_CTRL7_ENABLE_MASK)
def configMAG(self, device, odr):
pass
def configApply(self, inputSelection, accRange, accOdr, gyrRange, gyrOdr, aeOdr, magOdr, magDev):
fisSensors = inputSelection
if (fisSensors & FISIMU_CONFIG_AE_ENABLE):
self.configAe(aeOdr)
else:
if (inputSelection & FISIMU_CONFIG_ACC_ENABLE):
self.configACC(accRange, accOdr, Lpf_Enable, Hpf_Disable)
if (inputSelection & FISIMU_CONFIG_GYR_ENABLE):
self.configGyro(gyrRange, gyrOdr, Lpf_Enable, Hpf_Disable)
if (inputSelection & FISIMU_CONFIG_MAG_ENABLE):
self.configMAG(magDev, magOdr)
self.enableSensors(fisSensors)
# 得到温度值
# 返回值:温度值
def getTemperature(self):
temp = self.readReg(FisRegister_Temperature, 1)[0]
return round(temp, 2)
# 得到加速度值(原始值)
# (gx,gy,gz):陀螺仪x,y,z轴的重力加速度，单位：m/s²
# 返回值:0,成功
# 其他,错误代码
def getAcceleration(self):
global acc_lsb_div
buf_reg = bytearray(6)
raw_acc_xyz = [1, 2, 3]
acc_xyz = [1, 2, 3]
buf_reg[0] = self.readReg(FisRegister_Ax_L, 1)[0]
buf_reg[1] = self.readReg(FisRegister_Ax_H, 1)[0]
buf_reg[2] = self.readReg(FisRegister_Ay_L, 1)[0]
buf_reg[3] = self.readReg(FisRegister_Ay_H, 1)[0]
buf_reg[4] = self.readReg(FisRegister_Az_L, 1)[0]
buf_reg[5] = self.readReg(FisRegister_Az_H, 1)[0]
raw_acc_xyz[0] = self.int16((buf_reg[1] << 8) | (buf_reg[0]))
raw_acc_xyz[1] = self.int16((buf_reg[3] << 8) | (buf_reg[2]))
raw_acc_xyz[2] = self.int16((buf_reg[5] << 8) | (buf_reg[4]))
print("raw acc is acc0[%d] acc1[%d] acc2[%d]" %(raw_acc_xyz[0], raw_acc_xyz[1], raw_acc_xyz[2]))
acc_xyz[0] = (raw_acc_xyz[0] * ONE_G) / acc_lsb_div
acc_xyz[1] = (raw_acc_xyz[1] * ONE_G) / acc_lsb_div
acc_xyz[2] = (raw_acc_xyz[2] * ONE_G) / acc_lsb_div
print("fis210x acc is", acc_xyz[0], acc_xyz[1], acc_xyz[2])
return acc_xyz
# 得到陀螺仪值(原始值)
# gx,gy,gz:陀螺仪x,y,z轴的原始读数(带符号)
# 返回值:0,成功
# 其他,错误代码
def getGyro(self):
global gyro_lsb_div
buf_reg = bytearray(6)
raw_gyro_xyz = [1, 2, 3]
gyro_xyz = [1, 2, 3]
#buf_reg = self.readReg(FisRegister_Gx_L, 6)
buf_reg[0] = self.readReg(FisRegister_Gx_L, 1)[0]
buf_reg[1] = self.readReg(FisRegister_Gx_H, 1)[0]
buf_reg[2] = self.readReg(FisRegister_Gy_L, 1)[0]
buf_reg[3] = self.readReg(FisRegister_Gy_H, 1)[0]
buf_reg[4] = self.readReg(FisRegister_Gz_L, 1)[0]
buf_reg[5] = self.readReg(FisRegister_Gz_H, 1)[0]
raw_gyro_xyz[0] = self.int16((buf_reg[1] << 8) | (buf_reg[0]))
raw_gyro_xyz[1] = self.int16((buf_reg[3] << 8) | (buf_reg[2]))
raw_gyro_xyz[2] = self.int16((buf_reg[5] << 8) | (buf_reg[4]))
#print("raw gyro is g0[%d] g1[%d g2[%d]" %(raw_gyro_xyz[0], raw_gyro_xyz[1], raw_gyro_xyz[2]))
gyro_xyz[0] = (raw_gyro_xyz[0] * 1.0) / gyro_lsb_div
gyro_xyz[1] = (raw_gyro_xyz[1] * 1.0) / gyro_lsb_div
gyro_xyz[2] = (raw_gyro_xyz[2] * 1.0) / gyro_lsb_div
#print("fis210x gyro is", gyro_xyz[0], gyro_xyz[1], gyro_xyz[2])
return gyro_xyz
def getData(self):
global qmi8610_dict
qmi8610_dict['temp'] = self.getTemperature()
arr = self.getGyro()
qmi8610_dict['gyroX'] = arr[0]
qmi8610_dict['gyroY'] = arr[1]
qmi8610_dict['gyroZ'] = arr[2]
brr = self.getAcceleration()
qmi8610_dict['accX'] = brr[0]
qmi8610_dict['accY'] = brr[1]
qmi8610_dict['accZ'] = brr[2]
return qmi8610_dict
def init(self):
chip_id = 0x00
chip_id = self.readReg(FisRegister_WhoAmI, 1)[0]
sleep_ms(100)
if (chip_id == 0xfc):
inputSelection = FISIMU_CONFIG_ACCGYR_ENABLE
accRange = AccRange_4g
accOdr = AccOdr_128Hz
gyrRange = GyrRange_1024dps # GyrRange_1024dps;
gyrOdr = GyrOdr_256Hz # GyrOdr_1024Hz
magOdr = MagOdr_32Hz
magDev = MagDev_AK8963
aeOdr = AeOdr_32Hz
sleep_ms(100)
self.configApply(inputSelection, accRange, accOdr, gyrRange, gyrOdr, aeOdr, magOdr, magDev)
sleep_ms(100)
self.setLayout(2)
else:
chip_id = 0
return chip_id
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/fs/lib/qmi8610/qmi8610.py | Python | apache-2.0 | 25,897 |
"""
Copyright (C) 2015-2021 Alibaba Group Holding Limited
MicroPython's driver for QMP6988
Author: HaaS
Date: 2021/09/14
"""
from driver import I2C
from utime import sleep_ms
from micropython import const
import math
QMP6988_CALC_INT = 1
QMP6988_CHIP_ID = const(0x5C)
QMP6988_CHIP_ID_REG = const(0xD1)
QMP6988_RESET_REG = const(0xE0) # Device reset register
QMP6988_DEVICE_STAT_REG = const(0xF3) # Device state register
QMP6988_CTRLMEAS_REG = const(0xF4) # Measurement Condition Control Register
# data
QMP6988_PRESSURE_MSB_REG = const(0xF7) # Pressure MSB Register
QMP6988_TEMPERATURE_MSB_REG = const(0xFA) # Temperature MSB Reg
# compensation calculation
QMP6988_CALIBRATION_DATA_START = const(0xA0) # QMP6988 compensation coefficients
QMP6988_CALIBRATION_DATA_LENGTH = const(25)
SHIFT_RIGHT_4_POSITION = const(4)
SHIFT_LEFT_2_POSITION = const(2)
SHIFT_LEFT_4_POSITION = const(4)
SHIFT_LEFT_5_POSITION = const(5)
SHIFT_LEFT_8_POSITION = const(8)
SHIFT_LEFT_12_POSITION = const(12)
SHIFT_LEFT_16_POSITION = const(16)
# power mode
QMP6988_SLEEP_MODE = const(0x00)
QMP6988_FORCED_MODE = const(0x01)
QMP6988_NORMAL_MODE = const(0x03)
QMP6988_CTRLMEAS_REG_MODE__POS = const(0)
QMP6988_CTRLMEAS_REG_MODE__MSK = const(0x03)
QMP6988_CTRLMEAS_REG_MODE__LEN = const(2)
# oversampling
QMP6988_OVERSAMPLING_SKIPPED = const(0x00)
QMP6988_OVERSAMPLING_1X = const(0x01)
QMP6988_OVERSAMPLING_2X = const(0x02)
QMP6988_OVERSAMPLING_4X = const(0x03)
QMP6988_OVERSAMPLING_8X = const(0x04)
QMP6988_OVERSAMPLING_16X = const(0x05)
QMP6988_OVERSAMPLING_32X = const(0x06)
QMP6988_OVERSAMPLING_64X = const(0x07)
QMP6988_CTRLMEAS_REG_OSRST__POS = const(5)
QMP6988_CTRLMEAS_REG_OSRST__MSK = const(0xE0)
QMP6988_CTRLMEAS_REG_OSRST__LEN = const(3)
QMP6988_CTRLMEAS_REG_OSRSP__POS = const(2)
QMP6988_CTRLMEAS_REG_OSRSP__MSK = const(0x1C)
QMP6988_CTRLMEAS_REG_OSRSP__LEN = const(3)
# filter
QMP6988_FILTERCOEFF_OFF = const(0x00)
QMP6988_FILTERCOEFF_2 = const(0x01)
QMP6988_FILTERCOEFF_4 = const(0x02)
QMP6988_FILTERCOEFF_8 = const(0x03)
QMP6988_FILTERCOEFF_16 = const(0x04)
QMP6988_FILTERCOEFF_32 = const(0x05)
QMP6988_CONFIG_REG = const(0xF1) #IIR filter co-efficient setting Register
QMP6988_CONFIG_REG_FILTER__POS = const(0)
QMP6988_CONFIG_REG_FILTER__MSK = const(0x07)
QMP6988_CONFIG_REG_FILTER__LEN = const(3)
SUBTRACTOR = const(8388608)
qmp6988_dict = {'Ctemp': 0.0, 'Ftemp': 0.0,'pressure': 0.0, 'altitude': 0.0}
class qmp6988Error(Exception):
def __init__(self, value=0, msg="qmp6988 common error"):
self.value = value
self.msg = msg
def __str__(self):
return "Error code:%d, Error message: %s" % (self.value, str(self.msg))
__repr__ = __str__
class QMP6988(object):
"""
This class implements qmp6988 chip's defs.
"""
def __init__(self, i2cDev):
self._i2cDev = None
if not isinstance(i2cDev, I2C):
raise ValueError("parameter is not an I2C object")
# make QMP6988's internal object points to i2cDev
self._i2cDev = i2cDev
self.init()
self.ik_a0 = 0
self.ik_b00 = 0
self.ik_a1 = 0
self.ik_a2 = 0
self.ik_bt1 = 0
self.ik_bt2 = 0
self.ik_bp1 = 0
self.ik_b11 = 0
self.ik_bp2 = 0
self.ik_b12 = 0
self.ik_b21 = 0
self.ik_bp3 = 0
self.fk_a0 = 0.0
self.fk_b00 = 0.0
self.fk_a1 = 0.0
self.fk_a2 = 0.0
self.fk_bt1 = 0.0
self.fk_bt2 = 0.0
self.fk_bp1 = 0.0
self.fk_b11 = 0.0
self.fk_bp2 = 0.0
self.fk_b12 = 0.0
self.fk_b21 = 0.0
self.fk_bp3 = 0.0
self.power_mode = 0
self.temperature = 0
self.init()
def int16(self, dat):
#return int(dat)
if dat > 32767:
return dat - 65536
else:
return dat
def int32(self, dat):
#return int(dat)
if dat > (1 << 31):
return dat - (1 << 32)
else:
return dat
def int64(self, dat):
#return int(dat)
if dat > (1 << 63):
return dat - (1 << 64)
else:
return dat
#写寄存器
def writeReg(self, addr, value):
Reg = bytearray([addr, value])
self._i2cDev.write(Reg)
#print("--> write addr " + hex(addr) + ", value = " + hex(value))
return 0
#读寄存器
def readReg(self, addr, len):
Reg = bytearray([addr])
self._i2cDev.write(Reg)
sleep_ms(2)
tmp = bytearray(len)
self._i2cDev.read(tmp)
#print("<-- read addr " + hex(addr) + ", value = " + hex(tmp[0]))
return tmp
def deviceCheck(self):
ret = self.readReg(QMP6988_CHIP_ID_REG, 1)[0]
#print("qmp6988 read chip id = " + hex(ret))
if (ret == QMP6988_CHIP_ID):
return 0
else:
return 1
def getCalibrationData(self):
if (QMP6988_CALC_INT):
pass
else:
Conv_A_S = [[-6.30E-03, 4.30E-04],
[-1.90E-11, 1.20E-10],
[1.00E-01, 9.10E-02],
[1.20E-08, 1.20E-06],
[3.30E-02, 1.90E-02],
[2.10E-07, 1.40E-07],
[-6.30E-10, 3.50E-10],
[2.90E-13, 7.60E-13],
[2.10E-15, 1.20E-14],
[1.30E-16, 7.90E-17]]
a_data_u8r = bytearray(QMP6988_CALIBRATION_DATA_LENGTH)
for len in range(QMP6988_CALIBRATION_DATA_LENGTH):
a_data_u8r[len] = self.readReg(QMP6988_CALIBRATION_DATA_START + len, 1)[0]
COE_a0 = self.int32(((a_data_u8r[18] << SHIFT_LEFT_12_POSITION) | (a_data_u8r[19] << SHIFT_LEFT_4_POSITION) | (a_data_u8r[24] & 0x0f)) << 12)
COE_a0 = self.int32(COE_a0 >> SHIFT_LEFT_12_POSITION)
COE_a1 = self.int16((a_data_u8r[20] << SHIFT_LEFT_8_POSITION) | a_data_u8r[21])
COE_a2 = self.int16((a_data_u8r[22] << SHIFT_LEFT_8_POSITION) | a_data_u8r[23])
COE_b00 = self.int32((a_data_u8r[0] << SHIFT_LEFT_12_POSITION) | (a_data_u8r[1] << SHIFT_LEFT_4_POSITION) | ((a_data_u8r[24] & 0xf0) >> SHIFT_RIGHT_4_POSITION)) << 12
COE_b00 = self.int32(COE_b00 >> SHIFT_LEFT_12_POSITION)
COE_bt1 = self.int16((a_data_u8r[2] << SHIFT_LEFT_8_POSITION) | a_data_u8r[3])
COE_bt2 = self.int16((a_data_u8r[4] << SHIFT_LEFT_8_POSITION) | a_data_u8r[5])
COE_bp1 = self.int16((a_data_u8r[6] << SHIFT_LEFT_8_POSITION) | a_data_u8r[7])
COE_b11 = self.int16((a_data_u8r[8] << SHIFT_LEFT_8_POSITION) | a_data_u8r[9])
COE_bp2 = self.int16((a_data_u8r[10] << SHIFT_LEFT_8_POSITION) | a_data_u8r[11])
COE_b12 = self.int16((a_data_u8r[12] << SHIFT_LEFT_8_POSITION) | a_data_u8r[13])
COE_b21 = self.int16((a_data_u8r[14] << SHIFT_LEFT_8_POSITION) | a_data_u8r[15])
COE_bp3 = self.int16((a_data_u8r[16] << SHIFT_LEFT_8_POSITION) | a_data_u8r[17])
""""
print("<-----------calibration data-------------->")
print("COE_a0[%d] COE_a1[%d] COE_a2[%d] COE_b00[%d]" %(COE_a0, COE_a1, COE_a2, COE_b00))
print("COE_bt1[%d] COE_bt2[%d] COE_bp1[%d] COE_b11[%d]" %(COE_bt1, COE_bt2, COE_bp1, COE_b11))
print("COE_bp2[%d] COE_b12[%d] COE_b21[%d] COE_bp3[%d]" %(COE_bp2, COE_b12, COE_b21, COE_bp3))
print("<-----------calibration data-------------->")
"""
if (QMP6988_CALC_INT):
self.ik_a0 = COE_a0 # 20Q4
self.ik_b00 = COE_b00 # 20Q4
self.ik_a1 = self.int32(3608 * (COE_a1) - 1731677965) # 31Q23
self.ik_a2 = self.int32(16889 * (COE_a2) - 87619360) # 30Q47
self.ik_bt1 = self.int64(2982 * (COE_bt1) + 107370906) # 28Q15
self.ik_bt2 = self.int64(329854 * (COE_bt2) + 108083093) # 34Q38
self.ik_bp1 = self.int64(19923 * (COE_bp1) + 1133836764) # 31Q20
self.ik_b11 = self.int64(2406 * (COE_b11) + 118215883) # 28Q34
self.ik_bp2 = self.int64(3079 * (COE_bp2) - 181579595) # 29Q43
self.ik_b12 = self.int64(6846 * (COE_b12) + 85590281) # 29Q53
self.ik_b21 = self.int64(13836 * (COE_b21) + 79333336) # 29Q60
self.ik_bp3 = self.int64(2915 * (COE_bp3) + 157155561) # 28Q65
"""
print("<----------- int calibration data -------------->")
print("a0[%d] a1[%d] a2[%d] b00[%d]" %(self.ik_a0, self.ik_a1, self.ik_a2, self.ik_b00))
print("bt1[%d] bt2[%d] bp1[%d] b11[%d]" %(self.ik_bt1, self.ik_bt2, self.ik_bp1, self.ik_b11))
print("bp2[%d] b12[%d] b21[%d] bp3[%d]" %(self.ik_bp2, self.ik_b12, self.ik_b21, self.ik_bp3))
print("<----------- int calibration data -------------->")
"""
else:
self.fk_a0 = COE_a0 / 16.0
self.fk_b00 = COE_b00 / 16.0
self.fk_a1 = Conv_A_S[0][0] + Conv_A_S[0][1] * COE_a1 / 32767.0
self.fk_a2 = Conv_A_S[1][0] + Conv_A_S[1][1] * COE_a2 / 32767.0
self.fk_bt1 = Conv_A_S[2][0] + Conv_A_S[2][1] * COE_bt1 / 32767.0
self.fk_bt2 = Conv_A_S[3][0] + Conv_A_S[3][1] * COE_bt2 / 32767.0
self.fk_bp1 = Conv_A_S[4][0] + Conv_A_S[4][1] * COE_bp1 / 32767.0
self.fk_b11 = Conv_A_S[5][0] + Conv_A_S[5][1] * COE_b11 / 32767.0
self.fk_bp2 = Conv_A_S[6][0] + Conv_A_S[6][1] * COE_bp2 / 32767.0
self.fk_b12 = Conv_A_S[7][0] + Conv_A_S[7][1] * COE_b12 / 32767.0
self.fk_b21 = Conv_A_S[8][0] + Conv_A_S[8][1] * COE_b21 / 32767.0
self.fk_bp3 = Conv_A_S[9][0] + Conv_A_S[9][1] * COE_bp3 / 32767.0
def convTx02e(self, dt):
if (QMP6988_CALC_INT):
wk1 = self.int64((self.ik_a1) * (dt)) # 31Q23+24-1=54 (54Q23)
wk2 = self.int64(((self.ik_a2) * (dt)) >> 14) # 30Q47+24-1=53 (39Q33)
wk2 = self.int64((wk2 * (dt)) >> 10) # 39Q33+24-1=62 (52Q23)
wk2 = self.int64(((wk1 + wk2) // 32767) >> 19) # 54,52->55Q23 (20Q04)
ret = self.int16((self.ik_a0 + wk2) >> 4) # 21Q4 -> 17Q0
return ret
else:
pass
def getPressure02e(self, dp, tx):
if (QMP6988_CALC_INT):
wk1 = ((self.ik_bt1) * (tx)) # 28Q15+16-1=43 (43Q15)
wk2 = self.int64((self.ik_bp1 * (dp)) >> 5) # 31Q20+24-1=54 (49Q15)
wk1 += wk2 # 43,49->50Q15
wk2 = self.int64(((self.ik_bt2) * (tx)) >> 1) # 34Q38+16-1=49 (48Q37)
wk2 = self.int64((wk2 * self.int64(tx)) >> 8) # 48Q37+16-1=63 (55Q29)
wk3 = wk2 # 55Q29
wk2 = self.int64(((self.ik_b11) * (tx)) >> 4) # 28Q34+16-1=43 (39Q30)
wk2 = self.int64((wk2 * (dp)) >> 1) # 39Q30+24-1=62 (61Q29)
wk3 += wk2 # 55,61->62Q29
wk2 = self.int64(((self.ik_bp2) * (dp)) >> 13) # 29Q43+24-1=52 (39Q30)
wk2 = self.int64((wk2 * (dp)) >> 1) # 39Q30+24-1=62 (61Q29)
wk3 += wk2 # 62,61->63Q29
wk1 += self.int64(wk3 >> 14) # Q29 >> 14 -> Q15
wk2 = ((self.ik_b12) * (tx)) # 29Q53+16-1=45 (45Q53)
wk2 = (wk2 * (tx)) >> 22 # 45Q53+16-1=61 (39Q31)
wk2 = (wk2 * (dp)) > 1 # 39Q31+24-1=62 (61Q30)
wk3 = wk2 # 61Q30
wk2 = (self.int64(self.ik_b21) * (tx)) >> 6 # 29Q60+16-1=45 (39Q54)
wk2 = self.int64((wk2 * (dp)) >> 23) # 39Q54+24-1=62 (39Q31)
wk2 = self.int64((wk2 * self.int64(dp)) >> 1) # 39Q31+24-1=62 (61Q20)
wk3 += wk2 # 61,61->62Q30
wk2 = self.int64(((self.ik_bp3) * (dp)) >> 12) # 28Q65+24-1=51 (39Q53)
wk2 = self.int64((wk2 * (dp)) >> 23) # 39Q53+24-1=62 (39Q30)
wk2 = (wk2 * (dp)) # 39Q30+24-1=62 (62Q30)
wk3 += wk2 # 62,62->63Q30
wk1 += self.int64(wk3 >> 15) # Q30 >> 15 = Q15
wk1 = self.int64(wk1 // 32767)
wk1 = self.int64(wk1 >> 11) # Q15 >> 7 = Q4
wk1 += self.ik_b00 # Q4 + 20Q4
# wk1 >>= 4 # 28Q4 -> 24Q0
ret = self.int32(wk1)
# print("wk1[%d] wk2[%d] ret[%d]" %(wk1, wk2, ret))
return ret
else:
pass
def softwareReset(self):
pass
def setPowermode(self, power_mode):
# print("qmp_set_powermode ")
self.power_mode = power_mode
data = self.readReg(QMP6988_CTRLMEAS_REG,1)[0]
data = data & 0xfc
if (power_mode == QMP6988_SLEEP_MODE):
data |= 0x00
elif (power_mode == QMP6988_FORCED_MODE):
data |= 0x01
elif (power_mode == QMP6988_NORMAL_MODE):
data |= 0x03
self.writeReg(QMP6988_CTRLMEAS_REG, data)
# print("qmp_set_powermode 0xf4=0x", data)
sleep_ms(20)
def setFilter(self, filter):
data = (filter & 0x03)
self.writeReg(QMP6988_CONFIG_REG, data)
sleep_ms(20)
def setOversamplingP(self, oversampling_p):
data = self.readReg(QMP6988_CTRLMEAS_REG, 1)[0]
data &= 0xe3
data |= self.int16(oversampling_p << 2)
self.writeReg(QMP6988_CTRLMEAS_REG, data)
sleep_ms(20)
def setOversamplingT(self, oversampling_t):
data = self.readReg(QMP6988_CTRLMEAS_REG, 1)[0]
data &= 0x1f
data |= self.int16(oversampling_t << 5)
self.writeReg(QMP6988_CTRLMEAS_REG, data)
sleep_ms(20)
def calcAltitude(self, pressure, temp):
altitude = (pow((101325 / pressure), 1 / 5.257) - 1) * (temp + 273.15) / 0.0065
return altitude
def getData(self):
global qmp6988_dict
a_data_u8r = bytearray(6)
# press
a_data_u8r = self.readReg(QMP6988_PRESSURE_MSB_REG, 6)
P_read = (a_data_u8r[0] << SHIFT_LEFT_16_POSITION) | (a_data_u8r[1] << SHIFT_LEFT_8_POSITION) | (a_data_u8r[2])
P_raw = self.int32(P_read - SUBTRACTOR)
T_read = (a_data_u8r[3] << SHIFT_LEFT_16_POSITION) | (a_data_u8r[4] << SHIFT_LEFT_8_POSITION) | (a_data_u8r[5])
T_raw = self.int32(T_read - SUBTRACTOR)
if (QMP6988_CALC_INT):
T_int = self.convTx02e(T_raw)
P_int = self.getPressure02e(P_raw, T_int)
#self.temperature = float(T_int) / 256.0
Ctemp = float(T_int) / 256.0
Ftemp = (Ctemp * 9 / 5) + 32
Ftemp = round(Ftemp,2)
#self.pressure = float(P_int) / 16.0
qmp6988_dict['Ctemp'] = Ctemp
qmp6988_dict['Ftemp'] = Ftemp
qmp6988_dict['pressure'] = float(P_int) / 16.0
#print("int temp = %f Pressure = %f " %(self.temperature, self.pressure))
else:
Tr = self.fk_a0 + (self.fk_a1 * T_raw) + (self.fk_a2 * T_raw) *T_raw
# Unit centigrade
#self.temperature = float(Tr) / 256.0
qmp6988_dict['Ctemp'] = float(Tr) / 256.0
# compensation pressure, Unit Pa
qmp6988_dict['pressure'] = self.fk_b00 + (self.fk_bt1 * Tr) + (self.fk_bp1 * P_raw) + (self.fk_b11 * Tr) *P_raw + (self.fk_bt2 * Tr) *Tr + (self.fk_bp2 * P_raw) *P_raw + (self.fk_b12 * P_raw) *(Tr *Tr) + (self.fk_b21 * P_raw) *(P_raw *Tr) + (self.fk_bp3 * P_raw) *(P_raw *P_raw)
#print("float temp = %f Pressure = %f" %(self.temperature, self.pressure))
qmp6988_dict['altitude'] = self.calcAltitude(qmp6988_dict['pressure'], qmp6988_dict['Ctemp'])
#print("altitude = ",self.altitude)
return qmp6988_dict
def getTemperature(self):
return self.getData()['Ctemp']
def getTemperatureF(self):
return self.getData()['Ftemp']
def getPressure(self):
return self.getData()['pressure']
def getAltitude(self):
return self.getData()['altitude']
def init(self):
ret = self.deviceCheck()
if (ret != 0):
return 0
else:
pass
self.softwareReset()
self.getCalibrationData()
self.setPowermode(QMP6988_NORMAL_MODE)
self.setFilter(QMP6988_FILTERCOEFF_OFF)
self.setOversamplingP(QMP6988_OVERSAMPLING_2X)
self.setOversamplingT(QMP6988_OVERSAMPLING_1X)
if __name__ == "__main__":
'''
The below i2c configuration is needed in your board.json.
"qmp6988": {
"type": "I2C",
"port": 1,
"addrWidth": 7,
"freq": 100000,
"mode": "master",
"devAddr": 86
}
'''
print("Testing qmp6988 ...")
i2cDev = I2C()
i2cDev.open("qmp6988")
baroDev = QMC6988(i2cDev)
pressure = baroDev.getPressure()
print("pressure:%f" % (pressure))
i2cDev.close()
del baroDev
i2cDev.close()
print("Test qmp6988 done!")
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/fs/lib/qmp6988/qmp6988.py | Python | apache-2.0 | 16,991 |
from micropython import const
import utime
import framebuf
from driver import SPI
from driver import GPIO
# register definitions
SET_SCAN_DIR = const(0xc0)
LOW_COLUMN_ADDRESS = const(0x00)
HIGH_COLUMN_ADDRESS = const(0x10)
SET_PAGE_ADDRESS = const(0xB0)
SET_CONTRAST = const(0x81)
SET_ENTIRE_ON = const(0xa4)
SET_NORM_INV = const(0xa6)
SET_DISP = const(0xae)
SET_MEM_ADDR = const(0x20)
SET_COL_ADDR = const(0x21)
SET_PAGE_ADDR = const(0x22)
SET_DISP_START_LINE = const(0x40)
SET_SEG_REMAP = const(0xa0)
SET_MUX_RATIO = const(0xa8)
SET_COM_OUT_DIR = const(0xc0)
SET_DISP_OFFSET = const(0xd3)
SET_COM_PIN_CFG = const(0xda)
SET_DISP_CLK_DIV = const(0xd5)
SET_PRECHARGE = const(0xd9)
SET_VCOM_DESEL = const(0xdb)
SET_CHARGE_PUMP = const(0x8d)
class SH1106:
def __init__(self, width, height):
self.width = width
self.height = height
self.pages = self.height // 8
self.buffer = bytearray(self.pages * self.width)
fb = framebuf.FrameBuffer(
self.buffer, self.width, self.height, framebuf.MVLSB)
self.framebuf = fb
# set shortcuts for the methods of framebuf
self.fill = fb.fill
self.fillRect = fb.fill_rect
self.hline = fb.hline
self.vline = fb.vline
self.line = fb.line
self.rect = fb.rect
self.pixel = fb.pixel
self.scroll = fb.scroll
self.text = fb.text
self.blit = fb.blit
# print("init done")
self.initDisplay()
def initDisplay(self):
self.reset()
for cmd in (
SET_DISP | 0x00, # 关闭显示
SET_DISP_CLK_DIV, 0x80, # 设置时钟分频因子
SET_MUX_RATIO, self.height - 1, # 设置驱动路数 路数默认0x3F（1/64）
SET_DISP_OFFSET, 0x00, # 设置显示偏移 偏移默认为0
SET_DISP_START_LINE | 0x00, # 设置显示开始行[5:0]
SET_CHARGE_PUMP, 0x14, # 电荷泵设置 bit2，开启/关闭
# 设置内存地址模式 [1:0],00，列地址模式;01，行地址模式;10,页地址模式;默认10;
SET_MEM_ADDR, 0x02,
SET_SEG_REMAP | 0x01, # 段重定义设置,bit0:0,0->0;1,0->127;
# 设置COM扫描方向;bit3:0,普通模式;1,重定义模式 COM[N-1]->COM0;N:驱动路数
SET_COM_OUT_DIR | 0x08,
SET_COM_PIN_CFG, 0x12, # 设置COM硬件引脚配置 [5:4]配置
SET_PRECHARGE, 0xf1, # 设置预充电周期 [3:0],PHASE 1;[7:4],PHASE 2;
# 设置VCOMH 电压倍率 [6:4] 000,0.65*vcc;001,0.77*vcc;011,0.83*vcc;
SET_VCOM_DESEL, 0x30,
SET_CONTRAST, 0xff, # 对比度设置 默认0x7F（范围1~255，越大越亮）
SET_ENTIRE_ON, # 全局显示开启;bit0:1,开启;0,关闭;(白屏/黑屏)
SET_NORM_INV, # 设置显示方式;bit0:1,反相显示;0,正常显示
SET_DISP | 0x01): # 开启显示
self.write_cmd(cmd)
self.fill(1)
self.show()
def poweroff(self):
self.write_cmd(SET_DISP | 0x00)
def poweron(self):
self.write_cmd(SET_DISP | 0x01)
def rotate(self, flag, update=True):
if flag:
self.write_cmd(SET_SEG_REMAP | 0x01) # mirror display vertically
self.write_cmd(SET_SCAN_DIR | 0x08) # mirror display hor.
else:
self.write_cmd(SET_SEG_REMAP | 0x00)
self.write_cmd(SET_SCAN_DIR | 0x00)
if update:
self.show()
def sleep(self, value):
self.write_cmd(SET_DISP | (not value))
def contrast(self, contrast):
self.write_cmd(SET_CONTRAST)
self.write_cmd(contrast)
def invert(self, invert):
self.write_cmd(SET_NORM_INV | (invert & 1))
def show(self):
for page in range(self.height // 8):
self.write_cmd(SET_PAGE_ADDRESS | page)
self.write_cmd(LOW_COLUMN_ADDRESS)
self.write_cmd(HIGH_COLUMN_ADDRESS)
page_buffer = bytearray(self.width)
for i in range(self.width):
page_buffer[i] = self.buffer[self.width * page + i]
self.write_data(page_buffer)
def setBuffer(self, buffer):
for i in range(len(buffer)):
self.buffer[i] = buffer[i]
def drawXBM(self, x, y, w, h, bitmap):
x_byte = (w//8) + (w % 8 != 0)
for nbyte in range(len(bitmap)):
for bit in range(8):
if(bitmap[nbyte] & (0b10000000 >> bit)):
p_x = (nbyte % x_byte)*8+bit
p_y = nbyte//x_byte
self.pixel(x + p_x, y + p_y, 1)
# 以屏幕GRAM的原始制式去填充Buffer
def drawBuffer(self, x, y, w, h, bitmap):
y_byte = (h//8) + (h % 8 != 0)
for nbyte in range(len(bitmap)):
for bit in range(8):
if(bitmap[nbyte] & (1 << bit)):
p_y = (nbyte % y_byte)*8+bit
p_x = nbyte//y_byte
self.pixel(x + p_x, y + p_y, 1)
def fillRect(self, x, y, w, h, c):
self.fillRect(x, y, w, h, c)
def fillCircle(self, x0, y0, r, c):
x = 0
y = r
deltax = 3
deltay = 2 - r - r
d = 1 - r
#print(x)
#print(y)
#print(deltax)
#print(deltay)
#print(d)
self.pixel(x + x0, y + y0, c)
self.pixel(x + x0, -y + y0, c)
for i in range(-r + x0, r + x0):
self.pixel(i, y0, c)
while x < y:
if d < 0:
d += deltax
deltax += 2
x = x +1
else:
d += (deltax + deltay)
deltax += 2
deltay += 2
x = x +1
y = y -1
for i in range(-x + x0, x + x0):
self.pixel(i, -y + y0, c)
self.pixel(i, y + y0, c)
for i in range(-y + x0, y + x0):
self.pixel(i, -x + y0, c)
self.pixel(i, x + y0, c)
def drawCircle(self, x0, y0, r, w, c):
self.fillCircle(x0, y0, r, c)
self.fillCircle(x0, y0, r -w, 0)
def reset(self, res):
if res is not None:
res.write(1)
utime.sleep_ms(1)
res.write(0)
utime.sleep_ms(20)
res.write(1)
utime.sleep_ms(20)
class SH1106_I2C(SH1106):
def __init__(self, width, height, i2c, res=None, addr=0x3c):
self.i2c = i2c
self.addr = addr
self.res = res
self.temp = bytearray(2)
super().__init__(width, height)
def write_cmd(self, cmd):
self.temp[0] = 0x80 # Co=1, D/C#=0
self.temp[1] = cmd
self.i2c.write(self.temp)
def write_data(self, buf):
send_buf = bytearray(1 + len(buf))
send_buf[0] = 0x40
for i in range(len(buf)):
send_buf[i+1] = buf[i]
print(send_buf)
self.i2c.write(send_buf)
def reset(self):
super().reset(self.res)
class SH1106_SPI(SH1106):
def __init__(self, width, height, spi, dc, res=None, cs=None):
self.spi = spi
self.dc = dc
self.res = res
self.cs = cs
super().__init__(width, height)
def write_cmd(self, cmd):
if self.cs is not None:
self.cs.write(1)
self.dc.write(0)
self.cs.write(0)
self.spi.write(bytearray([cmd]))
self.cs.write(1)
else:
self.dc.write(0)
self.spi.write(bytearray([cmd]))
def write_data(self, buf):
if self.cs is not None:
self.cs.write(1)
self.dc.write(1)
self.cs.write(0)
self.spi.write(buf)
self.cs.write(1)
else:
self.dc.write(1)
self.spi.write(buf)
def reset(self):
super().reset(self.res)
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/fs/lib/sh1106/sh1106.py | Python | apache-2.0 | 7,916 |
"""
Copyright (C) 2015-2021 Alibaba Group Holding Limited
MicroPython's drive for SI7006
Author: HaaS
Date: 2021/09/09
"""
from driver import I2C
from utime import sleep_ms
# The commands provided by SI7006
Si7006_MEAS_REL_HUMIDITY_MASTER_MODE = 0xE5
Si7006_MEAS_REL_HUMIDITY_NO_MASTER_MODE = 0xF5
Si7006_MEAS_TEMP_MASTER_MODE = 0xE3
Si7006_MEAS_TEMP_NO_MASTER_MODE = 0xF3
Si7006_READ_OLD_TEMP = 0xE0
Si7006_RESET = 0xFE
Si7006_READ_ID_LOW_0 = 0xFA
Si7006_READ_ID_LOW_1 = 0x0F
Si7006_READ_ID_HIGH_0 = 0xFC
Si7006_READ_ID_HIGH_1 = 0xC9
Si7006_READ_Firmware_Revision_0 = 0x84
Si7006_READ_Firmware_Revision_1 = 0xB8
class SI7006Error(Exception):
def __init__(self, value=0, msg="si7006 common error"):
self.value = value
self.msg = msg
def __str__(self):
return "Error code:%d, Error message: %s" % (self.value, str(self.msg))
__repr__ = __str__
class SI7006(object):
"""
This class implements SI7006 chip's functions.
"""
# i2cDev should be an I2C object and it should be opened before __init__ is called
def __init__(self, i2cDev):
self._i2cDev = None
if not isinstance(i2cDev, I2C):
raise ValueError("parameter is not an I2C object")
# make SI7006's internal object points to i2cDev
self._i2cDev = i2cDev
def getVer(self):
"""
Get the firmware version of the chip.
"""
# make sure SI7006's internal object is valid before I2C operation
if self._i2cDev is None:
raise ValueError("invalid I2C object")
# send read firmware version command to SI7006
reg = bytearray([Si7006_READ_Firmware_Revision_0, Si7006_READ_Firmware_Revision_1])
self._i2cDev.write(reg)
sleep_ms(30)
version = bytearray(1)
# read the version info back
self._i2cDev.read(version)
return version[0]
def getID(self):
"""Get the chip ID."""
# make sure SI7006's internal object is valid before I2C operation
if self._i2cDev is None:
raise ValueError("invalid I2C object")
# send read chip id‘s lower part command to SI7006
reg = bytearray([Si7006_READ_ID_LOW_0, Si7006_READ_ID_LOW_1])
self._i2cDev.write(reg)
sleep_ms(30)
id_buf_low = bytearray(4)
# read the id info back
self._i2cDev.read(id_buf_low)
# send read chip id‘s higher part command to SI7006
reg = bytearray([Si7006_READ_ID_HIGH_0, Si7006_READ_ID_HIGH_1])
id_buf_high = bytearray(4)
self._i2cDev.read(id_buf_high)
return id_buf_low + id_buf_high
def getTemperature(self):
"""Get temperature."""
# make sure SI7006's internal object is valid before I2C operation
if self._i2cDev is None:
raise ValueError("invalid I2C object")
# send measure temperature command to SI7006
reg = bytearray([Si7006_MEAS_TEMP_NO_MASTER_MODE])
self._i2cDev.write(reg)
# wait for 30ms to wait for the measure finish according to SI7006's datasheet
sleep_ms(30)
readData = bytearray(2)
# read the temperature measure result
self._i2cDev.read(readData)
value = (readData[0] << 8 | readData[1])
# convert to actual temperature
if (value & 0xFFFC):
temperature = (175.72 * value) / 65536.0 - 46.85
return round(temperature, 1)
else:
raise SI7006Error("failed to get temperature.")
def getHumidity(self):
"""Get humidity."""
# make sure SI7006's internal object is valid before I2C operation
if self._i2cDev is None:
raise ValueError("invalid I2C object")
# send measure humidity command to SI7006
reg = bytearray([Si7006_MEAS_REL_HUMIDITY_NO_MASTER_MODE])
self._i2cDev.write(reg)
# wait for 30ms to wait for the measure finish according to SI7006's datasheet
sleep_ms(30)
readData = bytearray(2)
self._i2cDev.read(readData)
value = (readData[0] << 8) | readData[1]
# convert to actual humidity
if (value & 0xFFFE):
humidity = (125.0 * value) / 65535.0 - 6.0
return round(humidity)
else:
raise SI7006Error("failed to get humidity.")
def getTempHumidity(self):
"""Get temperature and humidity."""
# make sure SI7006's internal object is valid before I2C operation
if self._i2cDev is None:
raise ValueError("invalid I2C object")
# read tempperature and humidity in sequence
temphumidity = [0, 0]
temphumidity[0] = self.getTemperature()
temphumidity[1] = self.getHumidity()
return temphumidity
if __name__ == "__main__":
'''
The below i2c configuration is needed in your board.json.
"si7006": {
"type": "I2C",
"port": 1,
"addrWidth": 7,
"freq": 400000,
"mode": "master",
"devAddr": 64
}
'''
print("Testing si7006 ...")
i2cDev = I2C()
i2cDev.open("si7006")
si7006Dev = SI7006(i2cDev)
version = si7006Dev.getVer()
print("si7006 version is: %d" % version)
chipID = si7006Dev.getID()
print("si7006 chip id is:", chipID)
temperature = si7006Dev.getTemperature()
print("The temperature is: %f" % temperature)
humidity = si7006Dev.getHumidity()
print("The humidity is: %d" % humidity)
i2cDev.close()
print("Test si7006 done!")
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/fs/lib/si7006/si7006.py | Python | apache-2.0 | 5,698 |
"""
Copyright (C) 2015-2021 Alibaba Group Holding Limited
MicroPython's drive for SPL06
Author: HaaS
Date: 2021/09/09
"""
from driver import I2C
from utime import sleep_ms
import math
EEPROM_CHIP_ADDRESS = 0x77
spl06_dict = {'Ctemp': 0.0, 'Ftemp': 0.0,'pressure': 0.0, 'altitude': 0.0}
class SPL06(object):
"""
This class implements spl06 chip's defs.
"""
def __init__(self, i2cDev):
self._i2cDev = None
if not isinstance(i2cDev, I2C):
raise ValueError("parameter is not an I2C object")
# make SPL06's internal object points to i2cDev
self._i2cDev = i2cDev
self.init()
def i2c_eeprom_read_var(self, chipAddress, addr):
return self.devRegReadWrite1Byte(0, addr, 0)
def devRegRead1Byte(self, addr):
return self.devRegReadWrite1Byte(0, addr, 0)
def devRegReadWrite1Byte(self, mode, addr, value):
#0 read mode
#1 write mode
if (mode == 0):
Reg = bytearray([addr])
self._i2cDev.write(Reg)
sleep_ms(10)
tmp = bytearray(1)
self._i2cDev.read(tmp)
#print("<-- read addr " + str(addr) + ", value = " + str(tmp[0]))
return tmp[0]
else:
Reg = bytearray([addr, value])
self._i2cDev.write(Reg)
#print("--> write addr " + str(addr) + ", value = " + str(value))
return 0
def init(self):
tmp = 0
rRegID = bytearray([0x0D, 0x0])
wRegPressure8xOversampling = bytearray([0x06, 0x03])
wRegTemperature8xOversampling = bytearray([0x07, 0x83])
wRegContinuousTempAndPressureMeasurement = bytearray([0x08, 0B0111])
wRegFIFOPressureMeasurement = bytearray([0x09, 0x00])
tmp = rRegID
self.devRegReadWrite1Byte(0, tmp[0], tmp[1])
tmp = wRegPressure8xOversampling
self.devRegReadWrite1Byte(1, tmp[0], tmp[1])
tmp = wRegTemperature8xOversampling
self.devRegReadWrite1Byte(1, tmp[0], tmp[1])
tmp = wRegContinuousTempAndPressureMeasurement
self.devRegReadWrite1Byte(1, tmp[0], tmp[1])
tmp = wRegFIFOPressureMeasurement
self.devRegReadWrite1Byte(1, tmp[0], tmp[1])
# Get the firmware version of the chip.
def getID(self) :
reg = bytearray([0x0D])
version = bytearray(1)
self._i2cDev.write(reg)
self._i2cDev.read(version)
#print("spl06 ID is " + str(version[0]))
return version[0]
def get_altitude(self, pressure, seaLevelhPa):
if (seaLevelhPa == 0):
return -1
pressure /= 100
altitude = 44330 * (1.0 - math.pow(pressure / seaLevelhPa, 0.1903))
return altitude
def get_temperature_scale_factor(self):
tmp_Byte = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X07) # MSB
tmp_Byte = tmp_Byte & 0B00000111
#print("tmp_Byte: %d\n" %tmp_Byte)
if (tmp_Byte == 0B000):
k = 524288.0
elif (tmp_Byte == 0B001):
k = 1572864.0
elif (tmp_Byte == 0B010):
k = 3670016.0
elif (tmp_Byte == 0B011):
k = 7864320.0
elif (tmp_Byte == 0B100):
k = 253952.0
elif (tmp_Byte == 0B101):
k = 516096.0
elif (tmp_Byte == 0B110):
k = 1040384.0
elif (tmp_Byte == 0B111):
k = 2088960.0
#print("k=%d\n" %k)
return k
def get_pressure_scale_factor(self):
tmp_Byte = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X06) # MSB
# tmp_Byte = tmp_Byte >> 4 #Focus on bits 6-4 - measurement rate
tmp_Byte = tmp_Byte & 0B00000111 # Focus on 2-0 oversampling rate
# tmp_Byte = 0B011
# oversampling rate
if (tmp_Byte == 0B000):
k = 524288.0
elif (tmp_Byte == 0B001):
k = 1572864.0
elif (tmp_Byte == 0B010):
k = 3670016.0
elif (tmp_Byte == 0B011):
k = 7864320.0
elif (tmp_Byte == 0B100):
k = 253952.0
elif (tmp_Byte == 0B101):
k = 516096.0
elif (tmp_Byte == 0B110):
k = 1040384.0
elif (tmp_Byte == 0B111):
k = 2088960.0
#print("k=%d\n" %k)
return k
def get_traw(self):
tmp_MSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X03) # MSB
tmp_LSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X04) # LSB
tmp_XLSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X05) # XLSB
tmp = (tmp_MSB << 8) | tmp_LSB
tmp = (tmp << 8) | tmp_XLSB
if (tmp & (1 << 23)):
tmp = tmp | 0XFF000000 # Set left bits to one for 2's complement
# conversion of negitive number
#print("get_traw: tmp_MSB=%d, tmp_LSB=%d, tmp_XLSB=%d\n" %(tmp_MSB, tmp_LSB, tmp_XLSB))
return tmp
def get_praw(self):
tmp_MSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X00) # MSB
tmp_LSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X01) # LSB
tmp_XLSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X02) # XLSB
tmp = (tmp_MSB << 8) | tmp_LSB
tmp = (tmp << 8) | tmp_XLSB
if (tmp & (1 << 23)):
tmp = -((2 << 23) - tmp)
return tmp
def get_c0(self):
tmp_MSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X10)
tmp_LSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X11)
tmp_LSB = tmp_LSB >> 4
tmp = (tmp_MSB << 4) | tmp_LSB
if (tmp & (1 << 11)):
# Check for 2's complement negative number
tmp = tmp | 0XF000 # Set left bits to one for 2's complement
# conversion of negitive number
if (tmp > (1 << 15)):
tmp &= 0xFFFF
tmp = tmp - (1<<16)
#print("get_c0: tmp_MSB=%d, tmp_LSB=%d, tmp=%d\n" %(tmp_MSB, tmp_LSB, tmp))
return tmp
def get_c1(self):
tmp_MSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X11)
tmp_LSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X12)
tmp_MSB = tmp_MSB & 0XF
tmp = (tmp_MSB << 8) | tmp_LSB
if (tmp & (1 << 11)):
# Check for 2's complement negative number
tmp = tmp | 0XF000 # Set left bits to one for 2's complement
# conversion of negitive number
if (tmp > (1 << 15)):
tmp = tmp - (1<<16)
#print("get_c1: tmp_MSB=%d, tmp_LSB=%d, tmp=%d\n" %(tmp_MSB, tmp_LSB, tmp))
return tmp
def get_c00(self):
tmp_MSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X13)
tmp_LSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X14)
tmp_XLSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X15)
tmp_XLSB = tmp_XLSB >> 4
tmp = (tmp_MSB << 8) | tmp_LSB
tmp = (tmp << 4) | tmp_XLSB
tmp = tmp_MSB << 12 | tmp_LSB << 4 | tmp_XLSB >> 4
if (tmp & (1 << 19)):
tmp = tmp | 0XFFF00000 # Set left bits to one for 2's complement
# conversion of negitive number
return tmp
def get_c10(self):
tmp_MSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X15) # 4 bits
tmp_LSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X16) # 8 bits
tmp_XLSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X17) # 8 bits
tmp_MSB = tmp_MSB & 0b00001111
tmp = (tmp_MSB << 4) | tmp_LSB
tmp = (tmp << 8) | tmp_XLSB
tmp = tmp_MSB << 16 | tmp_LSB << 8 | tmp_XLSB
if (tmp & (1 << 19)):
tmp = tmp | 0XFFF00000 # Set left bits to one for 2's complement
# conversion of negitive number
if (tmp > (1 << 15)):
tmp &= 0xFFFF
tmp = tmp - (1<<16)
return tmp
def get_c01(self):
tmp_MSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X18)
tmp_LSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X19)
tmp = (tmp_MSB << 8) | tmp_LSB
if (tmp > (1 << 15)):
tmp = tmp - (1<<16)
return tmp
def get_c11(self):
tmp_MSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X1A)
tmp_LSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X1B)
tmp = (tmp_MSB << 8) | tmp_LSB
if (tmp > (1 << 15)):
tmp = tmp - (1<<16)
return tmp
def get_c20(self):
tmp_MSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X1C)
tmp_LSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X1D)
tmp = (tmp_MSB << 8) | tmp_LSB
if (tmp > (1 << 15)):
tmp = tmp - (1<<16)
return tmp
def get_c21(self):
tmp_MSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X1E)
tmp_LSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X1F)
tmp = (tmp_MSB << 8) | tmp_LSB
if (tmp > (1 << 15)):
tmp = tmp - (1<<16)
return tmp
def get_c30(self):
tmp_MSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X20)
tmp_LSB = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0X21)
tmp = (tmp_MSB << 8) | tmp_LSB
if (tmp > (1 << 15)):
tmp = tmp - (1<<16)
return tmp
def getData(self):
global spl06_dict
tmp = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0x0D)
tmp = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0x06)
tmp = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0x07)
tmp = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0x08)
tmp = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0x09)
tmp = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0x0A)
tmp = self.i2c_eeprom_read_var(EEPROM_CHIP_ADDRESS, 0x0B)
c0 = self.get_c0()
c1 = self.get_c1()
c00 = self.get_c00()
c10 = self.get_c10()
c01 = self.get_c01()
c11 = self.get_c11()
c20 = self.get_c20()
c21 = self.get_c21()
c30 = self.get_c30()
traw = self.get_traw()
traw_sc = traw / self.get_temperature_scale_factor()
traw_sc = round(traw_sc,2)
#print("traw_sc: %0.2f\n" %traw_sc)
Ctemp = c0 * 0.5 + c1 * traw_sc
Ctemp = round(Ctemp,2)
#print("Ctemp:" + str(Ctemp) + ". " + "c0:" + str(c0) + " c1" + str(c1) + " traw_sc:" + str(traw_sc))
Ftemp = (Ctemp * 9 / 5) + 32
Ftemp = round(Ftemp,2)
#print("Ftemp: %d" %Ftemp)
praw = self.get_praw()
praw_sc = (praw) / self.get_pressure_scale_factor()
#print("praw: %d" %praw)
#print("praw_sc: %d" %praw_sc)
#print("c00: %d" %c00)
#print("c10: %d" %c10)
#print("c20: %d" %c20)
#print("c30: %d" %c30)
#print("c01: %d" %c01)
#print("c11: %d" %c11)
#print("c21: %d" %c21)
pcomp =\
(c00) + \
praw_sc * ((c10) + \
praw_sc * ((c20) + praw_sc * (c30))) + \
traw_sc * (c01) + \
traw_sc * praw_sc * ((c11) + praw_sc * (c21))
pressure = pcomp
#print("pressure: %d" %pressure)
# local_pressure = 1010.5 # Look up local sea level pressure on
# google
local_pressure = \
1011.1 # Look up local sea level pressure on google # Local pressure
# from airport website 8/22
#print("Local Airport Sea Level Pressure: %0.2f mb\n" %local_pressure)
altitude = self.get_altitude(pcomp, local_pressure)
#print("altitude: %d" %altitude)
spl06_dict['Ctemp'] = round(Ctemp, 2)
spl06_dict['Ftemp'] = round(Ftemp, 2)
spl06_dict['pressure'] = round(pressure, 1)
spl06_dict['altitude'] = round(altitude, 1)
return spl06_dict
def getTemperature(self):
return self.getData()['Ctemp']
def getFTemperature(self):
return self.getData()['Ftemp']
def getPressure(self):
return self.getData()['pressure']
def getAltitude(self):
return self.getData()['altitude']
if __name__ == "__main__":
'''
The below i2c configuration is needed in your board.json.
"spl06": {
"type": "I2C",
"port": 1,
"addrWidth": 7,
"freq": 400000,
"mode": "master",
"devAddr": 119
}
'''
print("Testing spl06 ...")
i2cDev = I2C()
i2cDev.open("spl06")
baroDev = SPL06(i2cDev)
pressure = baroDev.getPressure()
print("pressure:%f" % (pressure))
i2cDev.close()
del baroDev
i2cDev.close()
print("Test spl06 done!")
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/fs/lib/spl06/spl06.py | Python | apache-2.0 | 12,801 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* Development of the code in this file was sponsored by Microbric Pty Ltd
*
* The MIT License (MIT)
*
* Copyright (c) 2014 Damien P. George
* Copyright (c) 2017 Pycom Limited
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include "gccollect.h"
#include <stdio.h>
#include "py/gc.h"
void gc_collect(void)
{
gc_collect_start();
gc_helper_collect_regs_and_stack();
#if MICROPY_PY_THREAD
mp_thread_gc_others();
#endif
gc_collect_end();
}
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/gccollect.c | C | apache-2.0 | 1,572 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* Development of the code in this file was sponsored by Microbric Pty Ltd
*
* The MIT License (MIT)
*
* Copyright (c) 2014 Damien P. George
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
void gc_collect(void);
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/gccollect.h | C | apache-2.0 | 1,327 |
/*
* Copyright (C) 2018 Alibaba Group Holding Limited
*/
/*
DESCRIPTION
This file provides example entry.
*/
#ifndef PY_ENGINE_EXAMPLE_H
#define PY_ENGINE_EXAMPLE_H
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
typedef struct {
int32_t argc;
int8_t **argv;
bool is_repl_mode;
} mpy_thread_args;
int32_t mpy_run(int32_t argc, int8_t **argv);
int32_t mpy_init(mpy_thread_args *args);
int32_t mpy_deinit(void);
void haas_main(int32_t argc, int8_t **argv);
#ifdef __cplusplus
}
#endif
#endif /* PY_ENGINE_EXAMPLE_H */
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/haas_main.h | C | apache-2.0 | 547 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* Development of the code in this file was sponsored by Microbric Pty Ltd
*
* The MIT License (MIT)
*
* Copyright (c) 2013-2016 Damien P. George
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include "py/builtin.h"
const char haas_help_text[] =
"Welcome to MicroPython on the HaaS!\r\n"
"\r\n"
"For generic online docs please visit "
"https://g.alicdn.com/HaaSAI/PythonDoc/quickstart/index.html\r\n"
"\r\n"
"Control commands:\r\n"
" CTRL-A -- on a blank line, enter raw REPL mode\r\n"
" CTRL-B -- on a blank line, enter normal REPL mode\r\n"
" CTRL-C -- interrupt a running program\r\n"
" CTRL-D -- on a blank line, do a soft reset of the board\r\n"
" CTRL-E -- on a blank line, enter paste mode\r\n"
"\r\n"
"For further help on a specific object, type help(obj)\r\n"
"For a list of available modules, type help('modules')\r\n";
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/help.c | C | apache-2.0 | 2,044 |
/*
* Copyright (C) 2015-2021 Alibaba Group Holding Limited
*/
#include <stdio.h>
#include "aos_hal_adc.h"
#include "modmachine.h"
#include "py/mperrno.h"
#include "py/mphal.h"
#include "py/runtime.h"
#include "ulog/ulog.h"
#if MICROPY_PY_MACHINE_ADC
#define LOG_TAG "machine_adc"
#define SAMPLEING_CYCLE 1200
#define MADC_CHECK_PARAMS() \
madc_obj_t *self = (madc_obj_t *)MP_OBJ_TO_PTR(self_in); \
do { \
if (self == NULL) { \
mp_raise_OSError(MP_EINVAL); \
return mp_const_none; \
} \
} while (0)
enum {
ADC_CHANNEL_0,
ADC_CHANNEL_1,
ADC_CHANNEL_MAX
};
enum {
ADC_WIDTH_9Bit,
ADC_WIDTH_10Bit,
ADC_WIDTH_11Bit,
ADC_WIDTH_12Bit,
ADC_WIDTH_13Bit,
};
typedef struct _madc_obj_t {
mp_obj_base_t base;
adc_dev_t dev;
uint8_t adc_bit_width;
uint8_t channel_id;
} madc_obj_t;
const mp_obj_type_t machine_adc_type;
STATIC madc_obj_t madc_obj[] = {
{ { &machine_adc_type }, { ADC_CHANNEL_0, { SAMPLEING_CYCLE }, NULL }, ADC_WIDTH_12Bit, ADC_CHANNEL_0 },
{ { &machine_adc_type }, { ADC_CHANNEL_1, { SAMPLEING_CYCLE }, NULL }, ADC_WIDTH_12Bit, ADC_CHANNEL_1 },
};
STATIC mp_obj_t madc_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args)
{
mp_arg_check_num(n_args, n_kw, 1, 1, true);
mp_int_t channel_id = mp_obj_get_int(args[0]);
madc_obj_t *self = NULL;
for (int i = 0; i < MP_ARRAY_SIZE(madc_obj); i++) {
if (channel_id == madc_obj[i].channel_id) {
self = &madc_obj[i];
break;
}
}
if (!self) {
mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("ChannelId[%d] Should Smaller Than %d"), channel_id,
ADC_CHANNEL_MAX);
}
return MP_OBJ_FROM_PTR(self);
}
STATIC void madc_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind)
{
MADC_CHECK_PARAMS();
mp_printf(print, "ADC(Channel(%u))", self->channel_id);
}
STATIC mp_obj_t madc_read_u16(mp_obj_t self_in)
{
MADC_CHECK_PARAMS();
mp_int_t output = -1;
mp_int_t ret = aos_hal_adc_voltage_value_get(&self->dev, &output, 0);
if (ret != 0) {
LOGE(LOG_TAG, "ADC read fail with ret=%d\n", ret);
return MP_OBJ_NEW_SMALL_INT(ret);
}
return MP_OBJ_NEW_SMALL_INT(output);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(madc_read_u16_obj, madc_read_u16);
// Legacy method
STATIC mp_obj_t madc_read(mp_obj_t self_in)
{
return madc_read_u16(self_in);
}
MP_DEFINE_CONST_FUN_OBJ_1(madc_read_obj, madc_read);
STATIC mp_obj_t madc_width(mp_obj_t self_in, mp_obj_t width_in)
{
MADC_CHECK_PARAMS();
uint8_t width = mp_obj_get_int(width_in);
switch (width) {
case ADC_WIDTH_9Bit:
self->adc_bit_width = 9;
break;
case ADC_WIDTH_10Bit:
self->adc_bit_width = 10;
break;
case ADC_WIDTH_11Bit:
self->adc_bit_width = 11;
break;
case ADC_WIDTH_12Bit:
self->adc_bit_width = 12;
break;
case ADC_WIDTH_13Bit:
self->adc_bit_width = 13;
break;
default:
break;
}
return mp_const_none;
}
MP_DEFINE_CONST_FUN_OBJ_2(madc_width_obj, madc_width);
STATIC mp_obj_t madc_init(mp_obj_t self_in, mp_obj_t width_in)
{
MADC_CHECK_PARAMS();
mp_int_t ret = aos_hal_adc_init(&self->dev);
return MP_OBJ_NEW_SMALL_INT(ret);
}
MP_DEFINE_CONST_FUN_OBJ_2(madc_init_obj, madc_init);
STATIC mp_obj_t madc_deinit(mp_obj_t self_in, mp_obj_t width_in)
{
MADC_CHECK_PARAMS();
mp_int_t ret = aos_hal_adc_finalize(&self->dev);
return MP_OBJ_NEW_SMALL_INT(ret);
}
MP_DEFINE_CONST_FUN_OBJ_2(madc_deinit_obj, madc_deinit);
STATIC const mp_rom_map_elem_t madc_locals_dict_table[] = {
{ MP_ROM_QSTR(MP_QSTR_init), MP_ROM_PTR(&madc_init_obj) },
{ MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&madc_read_obj) },
{ MP_ROM_QSTR(MP_QSTR_read_u16), MP_ROM_PTR(&madc_read_u16_obj) },
{ MP_ROM_QSTR(MP_QSTR_width), MP_ROM_PTR(&madc_width_obj) },
{ MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&madc_deinit_obj) },
{ MP_ROM_QSTR(MP_QSTR_WIDTH_9BIT), MP_ROM_INT(ADC_WIDTH_9Bit) },
{ MP_ROM_QSTR(MP_QSTR_WIDTH_10BIT), MP_ROM_INT(ADC_WIDTH_10Bit) },
{ MP_ROM_QSTR(MP_QSTR_WIDTH_11BIT), MP_ROM_INT(ADC_WIDTH_11Bit) },
{ MP_ROM_QSTR(MP_QSTR_WIDTH_12BIT), MP_ROM_INT(ADC_WIDTH_12Bit) },
{ MP_ROM_QSTR(MP_QSTR_WIDTH_13BIT), MP_ROM_INT(ADC_WIDTH_13Bit) },
};
STATIC MP_DEFINE_CONST_DICT(madc_locals_dict, madc_locals_dict_table);
const mp_obj_type_t machine_adc_type = {
{ &mp_type_type },
.name = MP_QSTR_ADC,
.print = madc_print,
.make_new = madc_make_new,
.locals_dict = (mp_obj_t)&madc_locals_dict,
};
#endif | YifuLiu/AliOS-Things | components/py_engine/adapter/haas/machine_adc.c | C | apache-2.0 | 4,925 |
/*
* Copyright (C) 2015-2021 Alibaba Group Holding Limited
*/
#if MICROPY_PY_MACHINE_DAC
#include <stdio.h>
#include "aos_hal_dac.h"
#include "modmachine.h"
#include "py/mphal.h"
#include "py/runtime.h"
#include "ulog/ulog.h"
#define LOG_TAG "machine_dac"
#define MDAC_CHECK_PARAMS() \
mdac_obj_t *self = (mdac_obj_t *)MP_OBJ_TO_PTR(self_in); \
do { \
if (self == NULL) { \
mp_raise_OSError(MP_EINVAL); \
return mp_const_none; \
} \
} while (0)
enum {
DAC_CHANNEL_0,
DAC_CHANNEL_1,
DAC_CHANNEL_MAX
};
typedef struct _mdac_obj_t {
mp_obj_base_t base;
dac_dev_t dev;
uint8_t channel_id;
} mdac_obj_t;
const mp_obj_type_t machine_dac_type;
STATIC mdac_obj_t mdac_obj[] = {
{ { &machine_dac_type }, { DAC_CHANNEL_0, NULL }, DAC_CHANNEL_0 },
{ { &machine_dac_type }, { DAC_CHANNEL_1, NULL }, DAC_CHANNEL_1 },
};
STATIC mp_obj_t mdac_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args)
{
mp_arg_check_num(n_args, n_kw, 1, 1, true);
mp_int_t channel_id = mp_obj_get_int(args[0]);
mdac_obj_t *self = NULL;
for (int i = 0; i < MP_ARRAY_SIZE(mdac_obj); i++) {
if (channel_id == mdac_obj[i].channel_id) {
self = &mdac_obj[i];
break;
}
}
if (!self) {
mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("ChannelId[%d] Should Smaller Than %d"), channel_id,
DAC_CHANNEL_MAX);
}
int status = aos_hal_dac_init(&self->dev);
if (status != 0) {
mp_raise_ValueError(MP_ERROR_TEXT("Failed to init DAC, parameter error"));
}
return MP_OBJ_FROM_PTR(self);
}
STATIC void mdac_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind)
{
MDAC_CHECK_PARAMS();
mp_printf(print, "DAC(Channel(%u))", self->channel_id);
}
STATIC mp_obj_t mdac_write(mp_obj_t self_in, mp_obj_t value_in)
{
MDAC_CHECK_PARAMS();
int value = mp_obj_get_int(value_in);
if (value < 0 || value > 255) {
mp_raise_ValueError(MP_ERROR_TEXT("value out of range"));
}
int status = aos_hal_dac_set_value(&self->dev, self->channel_id, value);
if (status != 0) {
LOGE(LOG_TAG, "DAC write fail!");
}
return mp_const_none;
}
MP_DEFINE_CONST_FUN_OBJ_2(mdac_write_obj, mdac_write);
STATIC mp_obj_t mdac_read(mp_obj_t self_in)
{
MDAC_CHECK_PARAMS();
mp_int_t res = aos_hal_dac_get_value(&self->dev, self->channel_id);
return MP_OBJ_NEW_SMALL_INT(res);
}
MP_DEFINE_CONST_FUN_OBJ_2(mdac_read_obj, mdac_read);
STATIC mp_obj_t mdac_start(mp_obj_t self_in)
{
MDAC_CHECK_PARAMS();
mp_int_t status = aos_hal_dac_start(&self->dev, self->channel_id);
return MP_OBJ_NEW_SMALL_INT(status);
}
MP_DEFINE_CONST_FUN_OBJ_2(mdac_start_obj, mdac_start);
STATIC mp_obj_t mdac_stop(mp_obj_t self_in)
{
MDAC_CHECK_PARAMS();
mp_int_t status = aos_hal_dac_stop(&self->dev, self->channel_id);
return MP_OBJ_NEW_SMALL_INT(status);
}
MP_DEFINE_CONST_FUN_OBJ_2(mdac_stop_obj, mdac_stop);
STATIC mp_obj_t mdac_deinit(mp_obj_t self_in)
{
MDAC_CHECK_PARAMS();
mp_int_t status = aos_hal_dac_finalize(&self->dev);
return MP_OBJ_NEW_SMALL_INT(status);
}
MP_DEFINE_CONST_FUN_OBJ_2(mdac_deinit_obj, mdac_deinit);
STATIC const mp_rom_map_elem_t mdac_locals_dict_table[] = {
{ MP_ROM_QSTR(MP_QSTR_start), MP_ROM_PTR(&mdac_start_obj) },
{ MP_ROM_QSTR(MP_QSTR_stop), MP_ROM_PTR(&mdac_stop_obj) },
{ MP_ROM_QSTR(MP_QSTR_write), MP_ROM_PTR(&mdac_write_obj) },
{ MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&mdac_read_obj) },
{ MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&mdac_deinit_obj) },
};
STATIC MP_DEFINE_CONST_DICT(mdac_locals_dict, mdac_locals_dict_table);
const mp_obj_type_t machine_dac_type = {
{ &mp_type_type },
.name = MP_QSTR_DAC,
.print = mdac_print,
.make_new = mdac_make_new,
.locals_dict = (mp_obj_t)&mdac_locals_dict,
};
#endif | YifuLiu/AliOS-Things | components/py_engine/adapter/haas/machine_dac.c | C | apache-2.0 | 4,179 |
/*
* Copyright (C) 2015-2021 Alibaba Group Holding Limited
*/
#include "aos_hal_i2c.h"
#include "extmod/machine_i2c.h"
#include "modmachine.h"
#include "py/mperrno.h"
#include "py/mphal.h"
#include "py/runtime.h"
#include "ulog/ulog.h"
#if MICROPY_PY_MACHINE_I2C
#define LOG_TAG "machine_hw_i2c"
#define MI2C_CHECK_PARAMS() \
machine_hw_i2c_obj_t *self = (machine_hw_i2c_obj_t *)MP_OBJ_TO_PTR(self_in); \
do { \
if (self == NULL) { \
mp_raise_OSError(MP_EINVAL); \
return mp_const_none; \
} \
} while (0)
#define I2C_0_DEFAULT_SCL (18)
#define I2C_0_DEFAULT_SDA (19)
#define I2C_1_DEFAULT_SCL (20)
#define I2C_1_DEFAULT_SDA (21)
#define I2C_DEFAULT_TIMEOUT_US (10000)
typedef enum {
I2C_NUM_0 = 0, /*!< I2C port 0 */
I2C_NUM_1, /*!< I2C port 1 */
I2C_NUM_MAX
} i2c_port_t;
typedef struct _machine_hw_i2c_obj_t {
mp_obj_base_t base;
uint16_t port : 8;
uint16_t scl : 8;
uint16_t sda : 8;
i2c_dev_t dev;
mp_uint_t timeout;
} machine_hw_i2c_obj_t;
STATIC machine_hw_i2c_obj_t machine_hw_i2c_obj[I2C_NUM_MAX];
mp_int_t mp_machine_hw_i2c_init(mp_obj_base_t *self_in, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args)
{
MI2C_CHECK_PARAMS();
i2c_dev_t *dev = &self->dev;
mp_int_t ret = -1;
mp_uint_t timeout = self->timeout;
uint8_t mode = dev->config.mode;
return aos_hal_i2c_init(dev);
}
mp_int_t mp_machine_hw_i2c_deinit(mp_obj_base_t *self_in)
{
MI2C_CHECK_PARAMS();
i2c_dev_t *dev = &self->dev;
return aos_hal_i2c_finalize(dev);
}
mp_int_t mp_machine_hw_i2c_transfer(mp_obj_base_t *self_in, uint16_t addr, size_t n, mp_machine_i2c_buf_t *bufs,
unsigned int flags)
{
MI2C_CHECK_PARAMS();
i2c_dev_t *dev = &self->dev;
mp_int_t ret = -1;
mp_uint_t timeout = self->timeout;
uint8_t mode = dev->config.mode;
int data_len = 0;
for (; n--; ++bufs) {
if (flags & MP_MACHINE_I2C_FLAG_READ) {
ret = aos_hal_i2c_mem_read(dev, dev->config.dev_addr, addr, n, bufs->buf, bufs->len, timeout);
} else {
if (bufs->len != 0) {
ret = aos_hal_i2c_mem_write(dev, dev->config.dev_addr, addr, n, bufs->buf, bufs->len, timeout);
}
}
if (ret != 0) {
LOGE(LOG_TAG, "mp_machine_hw_i2c_transfer fail, ret = %d\n", ret);
goto fail;
}
data_len += bufs->len;
}
return data_len;
fail:
return ret;
}
mp_int_t mp_machine_hw_i2c_write(mp_obj_base_t *self_in, const uint8_t *src, size_t len)
{
MI2C_CHECK_PARAMS();
i2c_dev_t *dev = &self->dev;
mp_int_t ret = -1;
mp_uint_t timeout = self->timeout;
uint8_t mode = dev->config.mode;
if (mode == I2C_MODE_MASTER) {
ret = aos_hal_i2c_master_send(dev, dev->config.dev_addr, src, len, timeout);
} else {
ret = aos_hal_i2c_slave_send(dev, src, len, timeout);
}
if(ret != 0) {
return ret;
}
return len;
}
mp_int_t mp_machine_hw_i2c_read(mp_obj_base_t *self_in, uint8_t *dest, size_t len, bool nack)
{
MI2C_CHECK_PARAMS();
i2c_dev_t *dev = &self->dev;
mp_int_t ret = -1;
mp_uint_t timeout = self->timeout;
uint8_t mode = dev->config.mode;
if (mode == I2C_MODE_MASTER) {
ret = aos_hal_i2c_master_recv(dev, dev->config.dev_addr, dest, len, timeout);
} else {
ret = aos_hal_i2c_slave_recv(dev, dest, len, timeout);
}
if (ret != 0) {
return ret;
}
return len;
}
/******************************************************************************/
// MicroPython bindings for machine API
STATIC void machine_hw_i2c_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind)
{
MI2C_CHECK_PARAMS();
i2c_dev_t *dev = &self->dev;
mp_printf(print,
"I2C(port=%u, scl=%u, sda=%u, freq=%u, addr_width=%u, "
"dev_addr=%u, mode=%u)",
self->port, self->scl, self->sda, dev->config.freq, dev->config.address_width, dev->config.dev_addr,
dev->config.mode);
}
STATIC mp_int_t machine_hw_i2c_init(machine_hw_i2c_obj_t *self, bool first_init)
{
i2c_dev_t *dev = &self->dev;
mp_int_t ret = -1;
if (!first_init) {
ret = aos_hal_i2c_finalize(dev);
if (ret != 0) {
LOGE(LOG_TAG, "aos_hal_i2c_finalize fail, ret = %d\n", ret);
}
}
ret = aos_hal_i2c_init(dev);
if (ret != 0) {
LOGE(LOG_TAG, "aos_hal_i2c_finalize fail, ret = %d\n", ret);
}
return ret;
}
mp_obj_t machine_hw_i2c_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args)
{
// Parse args
enum {
ARG_id,
ARG_scl,
ARG_sda,
ARG_freq,
ARG_timeout,
ARG_mode,
ARG_addr,
ARG_addrsize
};
static const mp_arg_t allowed_args[] = {
{ MP_QSTR_id, MP_ARG_REQUIRED | MP_ARG_OBJ, { .u_obj = MP_OBJ_NULL } },
{ MP_QSTR_scl, MP_ARG_KW_ONLY | MP_ARG_OBJ, { .u_obj = MP_OBJ_NULL } },
{ MP_QSTR_sda, MP_ARG_KW_ONLY | MP_ARG_OBJ, { .u_obj = MP_OBJ_NULL } },
{ MP_QSTR_freq, MP_ARG_KW_ONLY | MP_ARG_INT, { .u_int = I2C_BUS_BIT_RATES_400K } },
{ MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_INT, { .u_int = I2C_DEFAULT_TIMEOUT_US } },
{ MP_QSTR_mode, MP_ARG_KW_ONLY | MP_ARG_INT, { .u_int = I2C_MODE_MASTER } },
{ MP_QSTR_addr, MP_ARG_KW_ONLY | MP_ARG_INT, { .u_int = 0x00 } },
{ MP_QSTR_addrsize, MP_ARG_KW_ONLY | MP_ARG_INT, { .u_int = I2C_HAL_ADDRESS_WIDTH_7BIT } },
};
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
mp_arg_parse_all_kw_array(n_args, n_kw, all_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
// Get I2C bus
mp_int_t port = mp_obj_get_int(args[ARG_id].u_obj);
if (!(I2C_NUM_0 <= port && port < I2C_NUM_MAX)) {
mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("I2C(%d) doesn't exist"), port);
}
// Get static peripheral object
machine_hw_i2c_obj_t *self = (machine_hw_i2c_obj_t *)&machine_hw_i2c_obj[port];
bool first_init = false;
if (self->base.type == NULL) {
// Created for the first time, set default pins
self->base.type = &machine_hw_i2c_type;
self->port = port;
if (self->port == I2C_NUM_0) {
self->scl = I2C_0_DEFAULT_SCL;
self->sda = I2C_0_DEFAULT_SDA;
} else {
self->scl = I2C_1_DEFAULT_SCL;
self->sda = I2C_1_DEFAULT_SDA;
}
first_init = true;
}
// Set SCL/SDA pins if given
if (args[ARG_scl].u_obj != MP_OBJ_NULL) {
self->scl = mp_hal_get_pin_obj(args[ARG_scl].u_obj);
}
if (args[ARG_sda].u_obj != MP_OBJ_NULL) {
self->sda = mp_hal_get_pin_obj(args[ARG_sda].u_obj);
}
// Set Address width if given
mp_int_t addr_width = args[ARG_addrsize].u_int;
// Set freq if given
mp_int_t freq = args[ARG_freq].u_int;
// Set timeout if given
mp_int_t timeout = args[ARG_timeout].u_int;
// Set mode if given
mp_int_t mode = args[ARG_mode].u_int;
// Set addr if given
mp_int_t addr = args[ARG_addr].u_int;
i2c_dev_t *dev = &self->dev;
dev->port = port;
dev->config.address_width = addr_width;
dev->config.freq = freq;
dev->config.mode = mode;
dev->config.dev_addr = addr;
dev->priv = NULL;
self->timeout = timeout;
// Initialise the I2C peripheral
machine_hw_i2c_init(self, first_init);
return MP_OBJ_FROM_PTR(self);
}
STATIC const mp_machine_i2c_p_t machine_hw_i2c_p = {
.init = mp_machine_hw_i2c_init,
.deinit = mp_machine_hw_i2c_deinit,
.read = mp_machine_hw_i2c_read,
.write = mp_machine_hw_i2c_write,
.transfer = mp_machine_hw_i2c_transfer,
};
const mp_obj_type_t machine_hw_i2c_type = {
{ &mp_type_type },
.name = MP_QSTR_I2C,
.print = machine_hw_i2c_print,
.make_new = machine_hw_i2c_make_new,
.protocol = &machine_hw_i2c_p,
.locals_dict = (mp_obj_dict_t *)&mp_machine_i2c_locals_dict,
};
#endif | YifuLiu/AliOS-Things | components/py_engine/adapter/haas/machine_hw_i2c.c | C | apache-2.0 | 8,476 |
/*
* Copyright (C) 2015-2021 Alibaba Group Holding Limited
*/
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include "aos_hal_spi.h"
#include "extmod/machine_spi.h"
#include "modmachine.h"
#include "py/mphal.h"
#include "py/runtime.h"
#include "py/stream.h"
#include "ulog/ulog.h"
#if MICROPY_PY_MACHINE_SPI
#define LOG_TAG "machine_hw_spi"
#define MSPI_CHECK_PARAMS() \
machine_hw_spi_obj_t *self = (machine_hw_spi_obj_t *)MP_OBJ_TO_PTR(self_in); \
do { \
if (self == NULL) { \
mp_raise_OSError(MP_EINVAL); \
return mp_const_none; \
} \
} while (0)
typedef enum {
SPI_NUM_0 = 0, /*!< SPI port 0 */
SPI_NUM_1, /*!< SPI port 1 */
SPI_NUM_MAX
} spi_port_t;
typedef struct _machine_hw_spi_obj_t {
mp_obj_base_t base;
uint8_t port;
spi_dev_t dev;
} machine_hw_spi_obj_t;
// Static objects mapping to HSPI and VSPI hardware peripherals
STATIC machine_hw_spi_obj_t machine_hw_spi_obj[2] = { 0 };
#define SPI_TIMEOUT (1000)
STATIC void machine_hw_spi_deinit_internal(machine_hw_spi_obj_t *self)
{
spi_dev_t *dev = &self->dev;
aos_hal_spi_finalize(dev);
self->base.type = NULL;
}
STATIC mp_int_t machine_hw_spi_init_internal(machine_hw_spi_obj_t *self, bool first_init)
{
spi_dev_t *dev = &self->dev;
mp_int_t ret = -1;
if (!first_init) {
ret = aos_hal_spi_finalize(dev);
if (ret != 0) {
LOGE(LOG_TAG, "aos_hal_spi_finalize fail, ret = %d\n", ret);
}
self->base.type = NULL;
return ret;
}
// Initialize the SPI bus
ret = aos_hal_spi_init(dev);
if (ret != 0) {
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("invalid configuration"));
}
return ret;
}
STATIC void machine_hw_spi_deinit(mp_obj_base_t *self_in)
{
MSPI_CHECK_PARAMS();
spi_dev_t *dev = &self->dev;
mp_int_t ret = aos_hal_spi_finalize(dev);
if (ret != 0) {
LOGE(LOG_TAG, "aos_hal_spi_finalize fail, ret = %d\n", ret);
}
self->base.type = NULL;
}
STATIC void machine_hw_spi_transfer(mp_obj_base_t *self_in, size_t len, const uint8_t *src, uint8_t *dest)
{
MSPI_CHECK_PARAMS();
spi_dev_t *dev = &self->dev;
mp_int_t ret = -1;
MP_THREAD_GIL_EXIT();
// send operation
if (dest == NULL) {
ret = aos_hal_spi_send(dev, src, len, SPI_TIMEOUT);
if (ret != 0) {
LOGE(LOG_TAG, "aos_hal_spi_send fail, ret = %d\n", ret);
}
} else if (src == dest) {
ret = aos_hal_spi_recv(dev, dest, len, SPI_TIMEOUT);
if (ret != 0) {
LOGE(LOG_TAG, "aos_hal_spi_recv fail, ret = %d\n", ret);
}
} else {
ret = aos_hal_spi_send_recv(dev, (uint8_t *)src, dest, len, SPI_TIMEOUT);
if (ret != 0) {
LOGE(LOG_TAG, "aos_hal_spi_send_recv fail, ret = %d\n", ret);
}
}
MP_THREAD_GIL_ENTER();
}
/******************************************************************************/
// MicroPython bindings for hw_spi
STATIC void machine_hw_spi_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind)
{
MSPI_CHECK_PARAMS();
spi_dev_t *dev = &self->dev;
spi_config_t *cfg = &dev->config;
mp_printf(print,
"SPI(id=%u, role=%u, polarity=%u, mode=%u, t_mode=%u, freq=%u, "
"serial_len=%d, data_size=%d, cs=%d)",
dev->port, cfg->role, cfg->firstbit, cfg->mode, cfg->t_mode, cfg->freq, cfg->serial_len, cfg->data_size,
cfg->cs);
}
STATIC void machine_hw_spi_init(mp_obj_base_t *self_in, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args)
{
MSPI_CHECK_PARAMS();
spi_dev_t *dev = &self->dev;
enum {
ARG_baudrate,
ARG_polarity,
ARG_phase,
ARG_bits,
ARG_firstbit,
ARG_mode,
ARG_len
};
static const mp_arg_t allowed_args[] = {
{ MP_QSTR_baudrate, MP_ARG_KW_ONLY | MP_ARG_INT, { .u_int = 500000 } },
{ MP_QSTR_polarity, MP_ARG_KW_ONLY | MP_ARG_INT, { .u_int = 0 } },
{ MP_QSTR_phase, MP_ARG_KW_ONLY | MP_ARG_INT, { .u_int = 0 } },
{ MP_QSTR_bits, MP_ARG_KW_ONLY | MP_ARG_INT, { .u_int = SPI_DATA_SIZE_8BIT } },
{ MP_QSTR_firstbit, MP_ARG_KW_ONLY | MP_ARG_INT, { .u_int = MICROPY_PY_MACHINE_SPI_MSB } },
{ MP_QSTR_mode, MP_ARG_KW_ONLY | MP_ARG_INT, { .u_int = SPI_ROLE_MASTER } },
{ MP_QSTR_len, MP_ARG_KW_ONLY | MP_ARG_INT, { .u_int = DEFAULT_SPI_SERAIL_LEN } },
};
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
dev->config.role = args[ARG_mode].u_int;
dev->config.firstbit = args[ARG_firstbit].u_int;
dev->config.mode = (args[ARG_phase].u_int << 1) | args[ARG_polarity].u_int;
dev->config.freq = args[ARG_baudrate].u_int;
dev->config.serial_len = args[ARG_len].u_int;
dev->config.data_size = args[ARG_bits].u_int;
machine_hw_spi_init_internal(self, false);
}
mp_obj_t machine_hw_spi_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args)
{
enum {
ARG_id,
ARG_baudrate,
ARG_polarity,
ARG_phase,
ARG_bits,
ARG_firstbit,
ARG_mode,
ARG_len,
ARG_sck,
ARG_mosi,
ARG_miso
};
static const mp_arg_t allowed_args[] = {
{ MP_QSTR_id, MP_ARG_REQUIRED | MP_ARG_OBJ, { .u_int = 0 } },
{ MP_QSTR_baudrate, MP_ARG_KW_ONLY | MP_ARG_INT, { .u_int = 500000 } },
{ MP_QSTR_polarity, MP_ARG_KW_ONLY | MP_ARG_INT, { .u_int = 0 } },
{ MP_QSTR_phase, MP_ARG_KW_ONLY | MP_ARG_INT, { .u_int = 0 } },
{ MP_QSTR_bits, MP_ARG_KW_ONLY | MP_ARG_INT, { .u_int = SPI_DATA_SIZE_8BIT } },
{ MP_QSTR_firstbit, MP_ARG_KW_ONLY | MP_ARG_INT, { .u_int = MICROPY_PY_MACHINE_SPI_MSB } },
{ MP_QSTR_mode, MP_ARG_KW_ONLY | MP_ARG_INT, { .u_int = SPI_ROLE_MASTER } },
{ MP_QSTR_len, MP_ARG_KW_ONLY | MP_ARG_INT, { .u_int = DEFAULT_SPI_SERAIL_LEN } },
{ MP_QSTR_sck, MP_ARG_KW_ONLY | MP_ARG_OBJ, { .u_obj = MP_OBJ_NULL } },
{ MP_QSTR_mosi, MP_ARG_KW_ONLY | MP_ARG_OBJ, { .u_obj = MP_OBJ_NULL } },
{ MP_QSTR_miso, MP_ARG_KW_ONLY | MP_ARG_OBJ, { .u_obj = MP_OBJ_NULL } },
};
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
mp_arg_parse_all_kw_array(n_args, n_kw, all_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
// Get SPI bus
mp_int_t port = mp_obj_get_int(args[ARG_id].u_obj);
if (!(SPI_NUM_0 <= port && port < SPI_NUM_MAX)) {
mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("SPI(%d) doesn't exist"), port);
}
machine_hw_spi_obj_t *self;
if (port == 0) {
self = &machine_hw_spi_obj[0];
} else {
self = &machine_hw_spi_obj[1];
}
self->port = port;
bool first_init = false;
if (self->base.type == NULL) {
// Created for the first time, set default pins
self->base.type = &machine_hw_spi_type;
first_init = true;
}
spi_dev_t *dev = &self->dev;
dev->port = port;
dev->config.role = args[ARG_mode].u_int;
dev->config.firstbit = args[ARG_firstbit].u_int;
dev->config.mode = (args[ARG_phase].u_int << 1) | args[ARG_polarity].u_int;
dev->config.t_mode = SPI_TRANSFER_DMA;
dev->config.freq = args[ARG_baudrate].u_int;
dev->config.serial_len = args[ARG_len].u_int;
dev->config.data_size = args[ARG_bits].u_int;
dev->config.cs = SPI_CS_EN;
dev->priv = NULL;
machine_hw_spi_init_internal(self, first_init);
return MP_OBJ_FROM_PTR(self);
}
STATIC const mp_machine_spi_p_t machine_hw_spi_p = {
.init = machine_hw_spi_init,
.deinit = machine_hw_spi_deinit,
.transfer = machine_hw_spi_transfer,
};
const mp_obj_type_t machine_hw_spi_type = {
{ &mp_type_type },
.name = MP_QSTR_SPI,
.print = machine_hw_spi_print,
.make_new = machine_hw_spi_make_new,
.protocol = &machine_hw_spi_p,
.locals_dict = (mp_obj_dict_t *)&mp_machine_spi_locals_dict,
};
#endif | YifuLiu/AliOS-Things | components/py_engine/adapter/haas/machine_hw_spi.c | C | apache-2.0 | 8,439 |
/*
* Copyright (C) 2015-2021 Alibaba Group Holding Limited
*/
#include <stdio.h>
#include <string.h>
#include "extmod/virtpin.h"
#include "modmachine.h"
#include "mphalport.h"
#include "py/mphal.h"
#include "py/runtime.h"
#if MICROPY_PY_MACHINE
#include "aos_hal_gpio.h"
#include "ulog/ulog.h"
#define LOG_TAG "machine_pin"
// Used to implement a range of pull capabilities
#define GPIO_PULL_DOWN (1)
#define GPIO_PULL_UP (2)
#define GPIO_PULL_HOLD (4)
#define GPIO_AF (8)
#define GPIO_OD_NONE (16)
#define GPIO_OD_PULL_UP (32)
#define GPIO_PIN_INTR_LOLEVEL (0)
#define GPIO_PIN_INTR_HILEVEL (1)
typedef struct _machine_pin_obj_t {
mp_obj_base_t base;
mp_hal_pin_obj_t id;
gpio_irq_trigger_t trigger;
mp_obj_t callback;
} machine_pin_obj_t;
STATIC machine_pin_obj_t machine_pin_obj[PY_GPIO_NUM_MAX] = { 0 };
const mp_obj_type_t machine_pin_type;
void machine_pins_init(void)
{
static bool did_install = false;
if (!did_install) {
for (int i = 0; i < MP_ARRAY_SIZE(machine_pin_obj); ++i) {
machine_pin_obj[i].base.type = &machine_pin_type;
machine_pin_obj[i].id = 0;
machine_pin_obj[i].callback = NULL;
}
did_install = true;
}
}
void machine_pins_deinit(void)
{
for (int i = 0; i < MP_ARRAY_SIZE(machine_pin_obj); ++i) {
// aos_hal_gpio_disable_irq(&machine_pin_obj[i].dev);
}
}
STATIC void machine_pin_isr_handler(void *arg)
{
machine_pin_obj_t *self = (machine_pin_obj_t *)arg;
mp_obj_t callback = self->callback;
if (callback != mp_const_none && mp_obj_is_callable(callback)) {
callback_to_python_LoBo(callback, self, NULL);
}
}
mp_hal_pin_obj_t machine_pin_get_id(mp_obj_t pin_in)
{
if (mp_obj_get_type(pin_in) != &machine_pin_type) {
mp_raise_ValueError(MP_ERROR_TEXT("expecting a pin"));
}
machine_pin_obj_t *self = pin_in;
return self->id;
}
STATIC void machine_pin_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind)
{
machine_pin_obj_t *self = self_in;
mp_printf(print, "Pin(%u)", self->id);
}
// pin.init(mode, pull=None, *, value)
STATIC mp_obj_t machine_pin_obj_init_helper(const machine_pin_obj_t *self, size_t n_args, const mp_obj_t *pos_args,
mp_map_t *kw_args)
{
enum {
ARG_mode,
ARG_pull,
ARG_value
};
static const mp_arg_t allowed_args[] = {
{ MP_QSTR_mode, MP_ARG_OBJ, { .u_obj = mp_const_none } },
{ MP_QSTR_pull, MP_ARG_OBJ, { .u_obj = MP_OBJ_NEW_SMALL_INT(-1) } },
{ MP_QSTR_value, MP_ARG_KW_ONLY | MP_ARG_OBJ, { .u_obj = MP_OBJ_NULL } },
};
// parse args
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
// set initial value (do this before configuring mode/pull)
bool pin_initial_value = false;
if (args[ARG_value].u_obj != MP_OBJ_NULL) {
pin_initial_value = mp_obj_is_true(args[ARG_value].u_obj);
}
// configure mode
mp_int_t pin_io_mode = GPIO_INPUT;
if (args[ARG_mode].u_obj != mp_const_none) {
pin_io_mode = mp_obj_get_int(args[ARG_mode].u_obj);
}
// configure pull
mp_int_t pin_pull_mode = GPIO_PULL_UP;
if (args[ARG_pull].u_obj != MP_OBJ_NEW_SMALL_INT(-1)) {
int mode = 0;
if (args[ARG_pull].u_obj != mp_const_none) {
mode = mp_obj_get_int(args[ARG_pull].u_obj);
}
}
gpio_config_t config;
if (pin_io_mode == GPIO_INPUT) {
if (pin_pull_mode == GPIO_PULL_UP)
config = INPUT_PULL_UP;
else if (pin_pull_mode == GPIO_PULL_DOWN)
config = INPUT_PULL_DOWN;
else
config = INPUT_HIGH_IMPEDANCE;
} else if (pin_io_mode == GPIO_OUTPUT_PP) {
if (pin_pull_mode == GPIO_AF)
config = OUTPUT_PUSH_PULL_AF;
else
config = OUTPUT_PUSH_PULL;
} else if (pin_io_mode == GPIO_OUTPUT_OD) {
if (pin_pull_mode == GPIO_OD_NONE)
config = OUTPUT_OPEN_DRAIN_NO_PULL;
else if (pin_pull_mode == GPIO_OD_PULL_UP)
config = OUTPUT_OPEN_DRAIN_PULL_UP;
else if (pin_pull_mode == GPIO_AF)
config = OUTPUT_OPEN_DRAIN_AF;
}
mp_int_t ret = mp_hal_pin_config_set(self->id, config);
if (ret == 0) {
if (pin_io_mode != GPIO_INPUT) {
mp_hal_pin_write(self->id, pin_initial_value);
}
}
return MP_OBJ_NEW_SMALL_INT(ret);
}
// constructor(id, ...)
mp_obj_t mp_pin_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args)
{
mp_arg_check_num(n_args, n_kw, 1, MP_OBJ_FUN_ARGS_MAX, true);
// get the wanted pin object
int wanted_pin = mp_obj_get_int(args[0]);
machine_pin_obj_t *self = NULL;
if (0 <= wanted_pin && wanted_pin < MP_ARRAY_SIZE(machine_pin_obj)) {
self = (machine_pin_obj_t *)&machine_pin_obj[wanted_pin];
}
if (self->base.type == NULL) {
self->base.type = &machine_pin_type;
self->id = wanted_pin;
self->callback = mp_const_none;
}
if (n_args > 1 || n_kw > 0) {
// pin mode given, so configure this GPIO
mp_map_t kw_args;
mp_map_init_fixed_table(&kw_args, n_kw, args + n_args);
machine_pin_obj_init_helper(self, n_args - 1, args + 1, &kw_args);
}
return MP_OBJ_FROM_PTR(self);
}
// fast method for getting/setting pin value
STATIC mp_obj_t machine_pin_call(mp_obj_t self_in, size_t n_args, size_t n_kw, const mp_obj_t *args)
{
mp_arg_check_num(n_args, n_kw, 0, 1, false);
machine_pin_obj_t *self = self_in;
if (n_args == 0) {
// get pin
return MP_OBJ_NEW_SMALL_INT(mp_hal_pin_read(self->id));
} else {
// set pin
mp_hal_pin_write(self->id, mp_obj_is_true(args[0]));
return mp_const_none;
}
}
// pin.init(mode, pull)
STATIC mp_obj_t machine_pin_init(size_t n_args, const mp_obj_t *args, mp_map_t *kw_args)
{
return machine_pin_obj_init_helper(args[0], n_args - 1, args + 1, kw_args);
}
MP_DEFINE_CONST_FUN_OBJ_KW(machine_pin_init_obj, 1, machine_pin_init);
// pin.value([value])
STATIC mp_obj_t machine_pin_value(size_t n_args, const mp_obj_t *args)
{
return machine_pin_call(args[0], n_args - 1, 0, args + 1);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(machine_pin_value_obj, 1, 2, machine_pin_value);
// pin.off()
STATIC mp_obj_t machine_pin_off(mp_obj_t self_in)
{
machine_pin_obj_t *self = MP_OBJ_TO_PTR(self_in);
mp_hal_pin_write(self->id, 0);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(machine_pin_off_obj, machine_pin_off);
// pin.on()
STATIC mp_obj_t machine_pin_on(mp_obj_t self_in)
{
machine_pin_obj_t *self = MP_OBJ_TO_PTR(self_in);
mp_hal_pin_write(self->id, 1);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(machine_pin_on_obj, machine_pin_on);
// pin.irq(handler=None, trigger=IRQ_FALLING|IRQ_RISING)
STATIC mp_obj_t machine_pin_irq(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args)
{
enum {
ARG_handler,
ARG_trigger,
ARG_wake
};
static const mp_arg_t allowed_args[] = {
{ MP_QSTR_handler, MP_ARG_OBJ, { .u_obj = mp_const_none } },
{ MP_QSTR_trigger, MP_ARG_INT, { .u_int = IRQ_TRIGGER_RISING_EDGE | IRQ_TRIGGER_FALLING_EDGE } },
{ MP_QSTR_wake, MP_ARG_OBJ, { .u_obj = mp_const_none } },
};
machine_pin_obj_t *self = MP_OBJ_TO_PTR(pos_args[0]);
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
if (n_args > 1 || kw_args->used != 0) {
// configure irq
mp_obj_t handler = args[ARG_handler].u_obj;
mp_uint_t trigger = args[ARG_trigger].u_int;
mp_obj_t wake_obj = args[ARG_wake].u_obj;
if ((trigger == GPIO_PIN_INTR_LOLEVEL || trigger == GPIO_PIN_INTR_HILEVEL) && wake_obj != mp_const_none) {
mp_int_t wake;
if (mp_obj_get_int_maybe(wake_obj, &wake)) {
if (wake < 2 || wake > 7) {
mp_raise_ValueError(MP_ERROR_TEXT("bad wake value"));
}
} else {
mp_raise_ValueError(MP_ERROR_TEXT("bad wake value"));
}
} else {
if (handler == mp_const_none) {
handler = MP_OBJ_NULL;
trigger = 0;
}
self->callback = handler;
self->trigger = trigger;
gpio_dev_t dev = { 0 };
dev = mp_hal_gpio_dev_get(self->id);
aos_hal_gpio_enable_irq(&dev, trigger, machine_pin_isr_handler, (void *)self);
}
}
// return the irq object
return MP_OBJ_FROM_PTR(&machine_pin_obj[self->id]);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_KW(machine_pin_irq_obj, 1, machine_pin_irq);
STATIC mp_obj_t machine_pin_irq_enable(mp_obj_t self_in)
{
machine_pin_obj_t *self = MP_OBJ_TO_PTR(self_in);
if (self->callback == MP_OBJ_NULL) {
mp_raise_ValueError(MP_ERROR_TEXT("irq cabllback null"));
}
gpio_dev_t dev = { 0 };
dev = mp_hal_gpio_dev_get(self->id);
aos_hal_gpio_enable_irq(&dev, self->trigger, machine_pin_isr_handler, (void *)self);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(machine_pin_irq_enable_obj, machine_pin_irq_enable);
STATIC mp_obj_t machine_pin_irq_disable(mp_obj_t self_in)
{
machine_pin_obj_t *self = MP_OBJ_TO_PTR(self_in);
gpio_dev_t dev = { 0 };
dev = mp_hal_gpio_dev_get(self->id);
aos_hal_gpio_disable_irq(&dev);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(machine_pin_irq_disable_obj, machine_pin_irq_disable);
STATIC mp_obj_t machine_pin_deinit(mp_obj_t self_in)
{
machine_pin_obj_t *self = MP_OBJ_TO_PTR(self_in);
gpio_dev_t dev = { 0 };
dev = mp_hal_gpio_dev_get(self->id);
mp_int_t ret = -1;
if (mp_const_none != self->callback) {
ret = aos_hal_gpio_disable_irq(&dev);
ret = aos_hal_gpio_clear_irq(&dev);
}
ret = aos_hal_gpio_finalize(&dev);
self->callback = mp_const_none;
self->id = 0;
self->trigger = 0;
return MP_OBJ_NEW_SMALL_INT(ret);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(machine_pin_deinit_obj, machine_pin_deinit);
STATIC const mp_rom_map_elem_t machine_pin_locals_dict_table[] = {
// instance methods
{ MP_ROM_QSTR(MP_QSTR_init), MP_ROM_PTR(&machine_pin_init_obj) },
{ MP_ROM_QSTR(MP_QSTR_value), MP_ROM_PTR(&machine_pin_value_obj) },
{ MP_ROM_QSTR(MP_QSTR_off), MP_ROM_PTR(&machine_pin_off_obj) },
{ MP_ROM_QSTR(MP_QSTR_on), MP_ROM_PTR(&machine_pin_on_obj) },
{ MP_ROM_QSTR(MP_QSTR_irq), MP_ROM_PTR(&machine_pin_irq_obj) },
{ MP_ROM_QSTR(MP_QSTR_enable), MP_ROM_PTR(&machine_pin_irq_enable_obj) },
{ MP_ROM_QSTR(MP_QSTR_disable), MP_ROM_PTR(&machine_pin_irq_disable_obj) },
{ MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&machine_pin_deinit_obj) },
// class constants
{ MP_ROM_QSTR(MP_QSTR_IN), MP_ROM_INT(GPIO_INPUT) },
{ MP_ROM_QSTR(MP_QSTR_OUT), MP_ROM_INT(GPIO_OUTPUT_PP) },
{ MP_ROM_QSTR(MP_QSTR_OPEN_DRAIN), MP_ROM_INT(GPIO_OUTPUT_OD) },
{ MP_ROM_QSTR(MP_QSTR_PULL_UP), MP_ROM_INT(GPIO_PULL_UP) },
{ MP_ROM_QSTR(MP_QSTR_PULL_DOWN), MP_ROM_INT(GPIO_PULL_DOWN) },
{ MP_ROM_QSTR(MP_QSTR_PULL_HOLD), MP_ROM_INT(GPIO_PULL_HOLD) },
{ MP_ROM_QSTR(MP_QSTR_IRQ_RISING), MP_ROM_INT(IRQ_TRIGGER_RISING_EDGE) },
{ MP_ROM_QSTR(MP_QSTR_IRQ_FALLING), MP_ROM_INT(IRQ_TRIGGER_FALLING_EDGE) },
{ MP_ROM_QSTR(MP_QSTR_WAKE_LOW), MP_ROM_INT(GPIO_PIN_INTR_LOLEVEL) },
{ MP_ROM_QSTR(MP_QSTR_WAKE_HIGH), MP_ROM_INT(GPIO_PIN_INTR_HILEVEL) },
};
STATIC MP_DEFINE_CONST_DICT(machine_pin_locals_dict, machine_pin_locals_dict_table);
STATIC mp_uint_t pin_ioctl(mp_obj_t self_in, mp_uint_t request, uintptr_t arg, int *errcode)
{
(void)errcode;
machine_pin_obj_t *self = self_in;
mp_uint_t ret = 100;
switch (request) {
case MP_PIN_READ:
ret = mp_hal_pin_read(self->id);
break;
case MP_PIN_WRITE:
ret = mp_hal_pin_write(self->id, arg);
break;
}
return ret;
}
STATIC const mp_pin_p_t pin_pin_p = {
.ioctl = pin_ioctl,
};
const mp_obj_type_t machine_pin_type = {
{ &mp_type_type },
.name = MP_QSTR_Pin,
.print = machine_pin_print,
.make_new = mp_pin_make_new,
.call = machine_pin_call,
.protocol = &pin_pin_p,
.locals_dict = (mp_obj_t)&machine_pin_locals_dict,
};
#endif | YifuLiu/AliOS-Things | components/py_engine/adapter/haas/machine_pin.c | C | apache-2.0 | 12,628 |
/*
* Copyright (C) 2015-2021 Alibaba Group Holding Limited
*/
#include <stdio.h>
#include "aos_hal_pwm.h"
#include "modmachine.h"
#include "mphalport.h"
#include "py/mperrno.h"
#include "py/nlr.h"
#include "py/runtime.h"
#include "ulog/ulog.h"
#define LOG_TAG "machine_pwm"
enum {
PWN_CHANNEL_0,
PWN_CHANNEL_1,
PWN_CHANNEL_2,
PWN_CHANNEL_3,
PWN_CHANNEL_MAX
};
// Forward dec'l
extern const mp_obj_type_t machine_pwm_type;
// Params for PW operation
#define PWFREQ (5000)
#define PWDUTY (50)
typedef struct _machine_pwm_obj_t {
mp_obj_base_t base;
uint8_t id;
pwm_dev_t dev;
mp_uint_t duty_cycle;
mp_uint_t freq;
} machine_pwm_obj_t;
STATIC int update_param(machine_pwm_obj_t *self, mp_uint_t newfreq, mp_uint_t newduty)
{
int status = -1;
pwm_dev_t *dev = &self->dev;
mp_uint_t oduty = self->duty_cycle;
mp_uint_t ofreq = self->freq;
pwm_config_t cfg = {
.duty_cycle = newduty / 100.f,
.freq = newfreq,
};
status = aos_hal_pwm_para_chg(dev, cfg);
if (status != 0) {
LOGE(LOG_TAG, "aos_hal_pwm_para_chg failed, status=%d\n", status);
return status;
}
self->freq = newfreq;
self->duty_cycle = newduty / 100.f;
self->dev.config.freq = self->freq;
self->dev.config.duty_cycle = self->duty_cycle;
return status;
}
/******************************************************************************/
// MicroPython bindings for PWM
STATIC void machine_pwm_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind)
{
machine_pwm_obj_t *self = MP_OBJ_TO_PTR(self_in);
mp_printf(print, "PWM(%u", self->id);
mp_printf(print, ", freq=%u, duty=%u)", self->freq, self->duty_cycle);
}
STATIC void machine_pwm_init_helper(machine_pwm_obj_t *self, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args)
{
enum {
ARG_freq,
ARG_duty
};
static const mp_arg_t allowed_args[] = {
{ MP_QSTR_freq, MP_ARG_INT, { .u_int = -1 } },
{ MP_QSTR_duty, MP_ARG_INT, { .u_int = PWDUTY } },
};
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
pwm_dev_t *dev = &self->dev;
// Set freq and duty cycle?
mp_int_t freq = args[ARG_freq].u_int;
mp_int_t duty = args[ARG_duty].u_int;
/* if freq inited */
if (freq != -1) {
dev->config.duty_cycle = duty / 100.f;
dev->config.freq = freq;
int status = aos_hal_pwm_init(dev);
if (status != 0) {
LOGE(LOG_TAG, "aos_hal_pwm_init failed, status=%d\n", status);
return;
}
status = aos_hal_pwm_start(dev);
if (status != 0) {
LOGE(LOG_TAG, "aos_hal_pwm_start failed, status=%d\n", status);
}
}
}
STATIC mp_obj_t machine_pwm_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args)
{
mp_arg_check_num(n_args, n_kw, 1, MP_OBJ_FUN_ARGS_MAX, true);
// get PWM id
mp_int_t pwm_id = mp_obj_get_int(args[0]);
if (pwm_id < 0 || pwm_id >= PWN_CHANNEL_MAX) {
mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("PWM(%d) does not exist"), pwm_id);
}
// create PWM object from the given pin
machine_pwm_obj_t *self = m_new_obj(machine_pwm_obj_t);
self->base.type = &machine_pwm_type;
self->id = pwm_id;
self->duty_cycle = PWDUTY / 100.f;
self->freq = PWFREQ;
self->dev.port = pwm_id;
self->dev.config.duty_cycle = self->duty_cycle;
self->dev.config.freq = self->freq;
// start the PWM running for this channel
mp_map_t kw_args;
mp_map_init_fixed_table(&kw_args, n_kw, args + n_args);
machine_pwm_init_helper(self, n_args - 1, args + 1, &kw_args);
return MP_OBJ_FROM_PTR(self);
}
STATIC mp_obj_t machine_pwm_init(size_t n_args, const mp_obj_t *args, mp_map_t *kw_args)
{
machine_pwm_init_helper(args[0], n_args - 1, args + 1, kw_args);
return mp_const_none;
}
MP_DEFINE_CONST_FUN_OBJ_KW(machine_pwm_init_obj, 1, machine_pwm_init);
STATIC mp_obj_t machine_pwm_deinit(mp_obj_t self_in)
{
machine_pwm_obj_t *self = MP_OBJ_TO_PTR(self_in);
aos_hal_pwm_stop(&self->dev);
aos_hal_pwm_finalize(&self->dev);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(machine_pwm_deinit_obj, machine_pwm_deinit);
STATIC mp_obj_t machine_pwm_freq(size_t n_args, const mp_obj_t *args)
{
machine_pwm_obj_t *self = MP_OBJ_TO_PTR(args[0]);
if (n_args == 1) {
// get
return MP_OBJ_NEW_SMALL_INT(self->freq);
}
// set
int freq = mp_obj_get_int(args[1]);
int status = update_param(self, freq, self->duty_cycle);
return MP_OBJ_NEW_SMALL_INT(status);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(machine_pwm_freq_obj, 1, 2, machine_pwm_freq);
STATIC mp_obj_t machine_pwm_duty(size_t n_args, const mp_obj_t *args)
{
machine_pwm_obj_t *self = MP_OBJ_TO_PTR(args[0]);
if (n_args == 1) {
// get
return mp_obj_new_int(self->duty_cycle);
}
// set
mp_int_t duty = mp_obj_get_int(args[1]);
mp_int_t status = update_param(self, self->freq, duty);
return MP_OBJ_NEW_SMALL_INT(status);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(machine_pwm_duty_obj, 1, 2, machine_pwm_duty);
STATIC mp_obj_t machine_pwm_freqduty(size_t n_args, const mp_obj_t *args)
{
machine_pwm_obj_t *self = MP_OBJ_TO_PTR(args[0]);
mp_int_t freq = mp_obj_get_int(args[1]);
mp_int_t duty = mp_obj_get_int(args[2]);
int status = update_param(self, freq, duty);
return MP_OBJ_NEW_SMALL_INT(status);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(machine_pwm_freqduty_obj, 1, 2, machine_pwm_freqduty);
STATIC const mp_rom_map_elem_t machine_pwm_locals_dict_table[] = {
{ MP_ROM_QSTR(MP_QSTR_init), MP_ROM_PTR(&machine_pwm_init_obj) },
{ MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&machine_pwm_deinit_obj) },
{ MP_ROM_QSTR(MP_QSTR_freq), MP_ROM_PTR(&machine_pwm_freq_obj) },
{ MP_ROM_QSTR(MP_QSTR_duty), MP_ROM_PTR(&machine_pwm_duty_obj) },
{ MP_ROM_QSTR(MP_QSTR_freqduty), MP_ROM_PTR(&machine_pwm_freqduty_obj) },
};
STATIC MP_DEFINE_CONST_DICT(machine_pwm_locals_dict, machine_pwm_locals_dict_table);
const mp_obj_type_t machine_pwm_type = {
{ &mp_type_type },
.name = MP_QSTR_PWM,
.print = machine_pwm_print,
.make_new = machine_pwm_make_new,
.locals_dict = (mp_obj_dict_t *)&machine_pwm_locals_dict,
};
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/machine_pwm.c | C | apache-2.0 | 6,483 |
/*
* Copyright (C) 2015-2021 Alibaba Group Holding Limited
*/
#include <stdio.h>
#include <string.h>
#include <sys/time.h>
#include <time.h>
#include "aos_hal_rtc.h"
#include "shared/timeutils/timeutils.h"
#include "modmachine.h"
#include "py/mphal.h"
#include "py/nlr.h"
#include "py/obj.h"
#include "py/runtime.h"
#include "ulog/ulog.h"
#define LOG_TAG "machine_rtc"
const mp_obj_type_t machine_rtc_type;
typedef struct _machine_rtc_obj_t {
mp_obj_base_t base;
rtc_dev_t dev;
} machine_rtc_obj_t;
// singleton RTC object
STATIC const machine_rtc_obj_t machine_rtc_obj = { { &machine_rtc_type } };
STATIC mp_obj_t machine_rtc_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args)
{
// check arguments
mp_arg_check_num(n_args, n_kw, 0, 0, false);
rtc_dev_t *dev = &(machine_rtc_obj.dev);
dev->port = 0;
dev->config.format = HAL_RTC_FORMAT_DEC;
// return constant object
return (mp_obj_t)&machine_rtc_obj;
}
STATIC mp_obj_t machine_rtc_datetime_helper(mp_uint_t n_args, const mp_obj_t *args)
{
machine_rtc_obj_t *self = (machine_rtc_obj_t *)MP_OBJ_TO_PTR(args[0]);
if (n_args == 1) {
// Get time
rtc_time_t tm = { 0 };
aos_hal_rtc_get_time(&self->dev, &tm);
mp_obj_t tuple[7] = {
mp_obj_new_int(tm.year), mp_obj_new_int(tm.month), mp_obj_new_int(tm.date), mp_obj_new_int(tm.weekday),
mp_obj_new_int(tm.hr), mp_obj_new_int(tm.min), mp_obj_new_int(tm.sec),
};
return mp_obj_new_tuple(7, tuple);
} else {
// Set time
mp_obj_t *items = NULL;
mp_obj_get_array_fixed_n(args[1], 8, &items);
rtc_time_t tm = {
.year = mp_obj_get_int(items[0]),
.month = mp_obj_get_int(items[1]),
.date = mp_obj_get_int(items[2]),
.weekday = mp_obj_get_int(items[3]),
.hr = mp_obj_get_int(items[4]),
.min = mp_obj_get_int(items[5]),
.sec = mp_obj_get_int(items[6]),
};
aos_hal_rtc_set_time(&self->dev, &tm);
return mp_const_none;
}
}
STATIC mp_obj_t machine_rtc_datetime(mp_uint_t n_args, const mp_obj_t *args)
{
return machine_rtc_datetime_helper(n_args, args);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(machine_rtc_datetime_obj, 1, 2, machine_rtc_datetime);
STATIC mp_obj_t machine_rtc_init(mp_obj_t self_in, mp_obj_t date)
{
mp_obj_t args[2] = { self_in, date };
machine_rtc_datetime_helper(2, args);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_2(machine_rtc_init_obj, machine_rtc_init);
STATIC const mp_rom_map_elem_t machine_rtc_locals_dict_table[] = {
{ MP_ROM_QSTR(MP_QSTR_init), MP_ROM_PTR(&machine_rtc_init_obj) },
{ MP_ROM_QSTR(MP_QSTR_datetime), MP_ROM_PTR(&machine_rtc_datetime_obj) },
};
STATIC MP_DEFINE_CONST_DICT(machine_rtc_locals_dict, machine_rtc_locals_dict_table);
const mp_obj_type_t machine_rtc_type = {
{ &mp_type_type },
.name = MP_QSTR_RTC,
.make_new = machine_rtc_make_new,
.locals_dict = (mp_obj_t)&machine_rtc_locals_dict,
}; | YifuLiu/AliOS-Things | components/py_engine/adapter/haas/machine_rtc.c | C | apache-2.0 | 3,104 |
/*
* Copyright (C) 2015-2021 Alibaba Group Holding Limited
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aos/kernel.h"
#include "py/builtin.h"
#include "py/gc.h"
#include "py/mperrno.h"
#include "py/obj.h"
#include "py/runtime.h"
#include "py/stackctrl.h"
#include "ulog/ulog.h"
#define LOG_TAG "machine_sw_timer"
#define TIMER_MODE_ONESHOT (0)
#define TIMER_MODE_PERIODIC (1)
#define TIMER_DEFAULT_PERIOD (1000U)
typedef struct _machine_soft_timer_obj_t {
mp_obj_base_t base;
mp_uint_t port;
mp_uint_t period;
mp_uint_t reload_mode;
void *arg;
aos_timer_t *timerId;
mp_obj_t callback;
} machine_soft_timer_obj_t;
const mp_obj_type_t mp_machine_soft_timer_type;
STATIC void machine_soft_timer_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind)
{
machine_soft_timer_obj_t *self = MP_OBJ_TO_PTR(self_in);
mp_printf(print, "port=%d, ", self->port);
mp_printf(print, "period=%d, ", self->period);
mp_printf(print, "reload_mode=%d, ", self->reload_mode);
}
STATIC mp_obj_t machine_soft_timer_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args)
{
mp_arg_check_num(n_args, n_kw, 1, 1, false);
mp_uint_t port = mp_obj_get_int(args[0]);
machine_soft_timer_obj_t *swtimer_obj = m_new_obj(machine_soft_timer_obj_t);
if (!swtimer_obj) {
mp_raise_OSError(MP_EINVAL);
return mp_const_none;
}
memset(swtimer_obj, 0, sizeof(machine_soft_timer_obj_t));
swtimer_obj->base.type = &mp_machine_soft_timer_type;
swtimer_obj->port = port;
return MP_OBJ_FROM_PTR(swtimer_obj);
}
STATIC void machine_soft_timer_enable(machine_soft_timer_obj_t *self)
{
aos_timer_t *tim = self->timerId;
aos_timer_start(tim);
}
STATIC void machine_soft_timer_disable(machine_soft_timer_obj_t *self)
{
aos_timer_t *tim = self->timerId;
aos_timer_stop(tim);
}
STATIC void machine_soft_timer_isr(void *timer, void *self_in)
{
machine_soft_timer_obj_t *self = (machine_soft_timer_obj_t *)MP_OBJ_TO_PTR(self_in);
mp_obj_t callback = self->callback;
if (callback != mp_const_none && mp_obj_is_callable(callback)) {
callback_to_python_LoBo(callback, self, NULL);
}
}
STATIC mp_obj_t machine_soft_timer_init_helper(machine_soft_timer_obj_t *self, mp_uint_t n_args,
const mp_obj_t *pos_args, mp_map_t *kw_args)
{
enum {
ARG_mode,
ARG_callback,
ARG_period,
};
static const mp_arg_t allowed_args[] = {
{ MP_QSTR_mode, MP_ARG_KW_ONLY | MP_ARG_INT, { .u_int = AOS_TIMER_REPEAT | AOS_TIMER_AUTORUN } },
{ MP_QSTR_callback, MP_ARG_KW_ONLY | MP_ARG_OBJ, { .u_obj = mp_const_none } },
{ MP_QSTR_period, MP_ARG_KW_ONLY | MP_ARG_INT, { .u_int = TIMER_DEFAULT_PERIOD } },
};
machine_soft_timer_disable(self);
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
if (self == NULL) {
LOGD(LOG_TAG, "%s: machine_soft_timer_init_helper failed\n", __func__);
return mp_const_none;
}
self->callback = args[ARG_callback].u_obj;
self->reload_mode = args[ARG_mode].u_int;
self->period = (mp_uint_t)args[ARG_period].u_int;
self->arg = (void *)self;
mp_int_t status = aos_timer_create(self->timerId, machine_soft_timer_isr, self->arg, self->period,
(self->reload_mode | AOS_TIMER_AUTORUN));
if (status != 0) {
LOGE(LOG_TAG, "%s, %d, aos_timer_create failed\n", __func__, __LINE__);
return mp_const_none;
}
return mp_const_none;
}
STATIC mp_obj_t machine_soft_timer_deinit(mp_obj_t self_in)
{
machine_soft_timer_obj_t *self = (machine_soft_timer_obj_t *)MP_OBJ_TO_PTR(self_in);
machine_soft_timer_disable(self);
aos_timer_free(self->timerId);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(machine_soft_timer_deinit_obj, machine_soft_timer_deinit);
STATIC mp_obj_t machine_soft_timer_init(size_t n_args, const mp_obj_t *args, mp_map_t *kw_args)
{
return machine_soft_timer_init_helper(args[0], n_args - 1, args + 1, kw_args);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_KW(machine_soft_timer_init_obj, 1, machine_soft_timer_init);
STATIC mp_obj_t machine_soft_timer_period(mp_obj_t self_in, mp_obj_t period)
{
machine_soft_timer_obj_t *self = (machine_soft_timer_obj_t *)MP_OBJ_TO_PTR(self_in);
if (self_in == NULL) {
mp_raise_OSError(ENOENT);
return mp_const_none;
} else {
self->period = mp_obj_get_int(period);
}
mp_int_t ret = aos_timer_change(self->timerId, self->period);
return MP_OBJ_NEW_SMALL_INT(ret);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_2(machine_soft_timer_period_obj, machine_soft_timer_period);
STATIC mp_obj_t machine_soft_timer_start(mp_obj_t self_in)
{
machine_soft_timer_obj_t *self = (machine_soft_timer_obj_t *)MP_OBJ_TO_PTR(self_in);
mp_int_t ret = aos_timer_start(self->timerId);
return MP_OBJ_NEW_SMALL_INT(ret);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(machine_soft_timer_start_obj, machine_soft_timer_start);
STATIC mp_obj_t machine_soft_timer_stop(mp_obj_t self_in)
{
machine_soft_timer_obj_t *self = (machine_soft_timer_obj_t *)MP_OBJ_TO_PTR(self_in);
aos_timer_stop(self->timerId);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(machine_soft_timer_stop_obj, machine_soft_timer_stop);
STATIC mp_obj_t machine_soft_timer_value(mp_obj_t self_in)
{
machine_soft_timer_obj_t *self = (machine_soft_timer_obj_t *)MP_OBJ_TO_PTR(self_in);
uint64_t time_ns[4] = { 0 };
aos_timer_gettime(self->timerId, time_ns);
return MP_OBJ_NEW_SMALL_INT((mp_uint_t)(time_ns[0] * 1000 + time_ns[1] / 10000000)); // value in ms
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(machine_soft_timer_value_obj, machine_soft_timer_value);
STATIC const mp_rom_map_elem_t machine_soft_timer_locals_dict_table[] = {
{ MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&machine_soft_timer_deinit_obj) },
{ MP_ROM_QSTR(MP_QSTR_init), MP_ROM_PTR(&machine_soft_timer_init_obj) },
{ MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&machine_soft_timer_deinit_obj) },
{ MP_ROM_QSTR(MP_QSTR_start), MP_ROM_PTR(&machine_soft_timer_start_obj) },
{ MP_ROM_QSTR(MP_QSTR_stop), MP_ROM_PTR(&machine_soft_timer_stop_obj) },
{ MP_ROM_QSTR(MP_QSTR_period), MP_ROM_PTR(&machine_soft_timer_period_obj) },
{ MP_ROM_QSTR(MP_QSTR_value), MP_ROM_PTR(&machine_soft_timer_value_obj) },
{ MP_ROM_QSTR(MP_QSTR_ONE_SHOT), MP_ROM_INT(TIMER_MODE_ONESHOT) },
{ MP_ROM_QSTR(MP_QSTR_PERIODIC), MP_ROM_INT(TIMER_MODE_PERIODIC) },
};
STATIC MP_DEFINE_CONST_DICT(machine_soft_timer_locals_dict, machine_soft_timer_locals_dict_table);
const mp_obj_type_t mp_machine_soft_timer_type = {
{ &mp_type_type },
.name = MP_QSTR_SoftTimer,
.print = machine_soft_timer_print,
.make_new = machine_soft_timer_make_new,
.locals_dict = (mp_obj_t)&machine_soft_timer_locals_dict,
};
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/machine_sw_timer.c | C | apache-2.0 | 7,076 |
/*
* Copyright (C) 2015-2021 Alibaba Group Holding Limited
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aos_hal_timer.h"
#include "py/builtin.h"
#include "py/gc.h"
#include "py/mperrno.h"
#include "py/obj.h"
#include "py/runtime.h"
#include "py/stackctrl.h"
#include "ulog/ulog.h"
#include "utility.h"
#define LOG_TAG "machine_timer"
#define TIMER_MODE_ONESHOT (TIMER_RELOAD_MANU)
#define TIMER_MODE_PERIODIC (TIMER_RELOAD_AUTO)
#define TIMER_DEFAULT_PERIOD (1000000U)
typedef struct _machine_timer_obj_t {
mp_obj_base_t base;
mp_uint_t port;
timer_dev_t dev;
mp_obj_t callback;
} machine_timer_obj_t;
const mp_obj_type_t machine_timer_type;
STATIC void machine_timer_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind)
{
machine_timer_obj_t *self = MP_OBJ_TO_PTR(self_in);
mp_printf(print, "port=%d, ", self->port);
mp_printf(print, "period=%d, ", self->dev.config.period);
mp_printf(print, "reload_mode=%d, ", self->dev.config.reload_mode);
}
STATIC mp_obj_t machine_timer_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args)
{
mp_arg_check_num(n_args, n_kw, 1, 1, false);
mp_uint_t port = mp_obj_get_int(args[0]);
machine_timer_obj_t *timer_obj = m_new_obj(machine_timer_obj_t);
if (!timer_obj) {
mp_raise_OSError(MP_EINVAL);
return mp_const_none;
}
memset(timer_obj, 0, sizeof(machine_timer_obj_t));
timer_obj->base.type = &machine_timer_type;
timer_obj->port = port;
timer_obj->dev.port = port;
return MP_OBJ_FROM_PTR(timer_obj);
}
STATIC void machine_timer_disable(timer_dev_t *tim)
{
aos_hal_timer_stop(tim);
}
STATIC mp_int_t aos_timer_reload(timer_dev_t *tim)
{
return aos_hal_timer_reload(tim);
}
STATIC void machine_timer_isr(void *self_in)
{
machine_timer_obj_t *self = (machine_timer_obj_t *)self_in;
mp_obj_t callback = self->callback;
if (callback != mp_const_none && mp_obj_is_callable(callback)) {
callback_to_python_LoBo(callback, self, NULL);
}
}
STATIC void machine_timer_enable(machine_timer_obj_t *self)
{
timer_dev_t *tim = &self->dev;
if (tim != NULL) {
aos_hal_timer_init(tim);
aos_hal_timer_start(tim);
}
}
STATIC mp_obj_t machine_timer_init_helper(machine_timer_obj_t *self, mp_uint_t n_args, const mp_obj_t *pos_args,
mp_map_t *kw_args)
{
enum {
ARG_period,
ARG_mode,
ARG_callback,
};
static const mp_arg_t allowed_args[] = {
{ MP_QSTR_period, MP_ARG_KW_ONLY | MP_ARG_INT, { .u_int = TIMER_DEFAULT_PERIOD } },
{ MP_QSTR_mode, MP_ARG_KW_ONLY | MP_ARG_INT, { .u_int = TIMER_MODE_PERIODIC } },
{ MP_QSTR_callback, MP_ARG_KW_ONLY | MP_ARG_OBJ, { .u_obj = mp_const_none } },
};
machine_timer_disable(&self->dev);
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
if (self == NULL) {
LOGE(LOG_TAG, "%s: hal_timer_init failed\n", __func__);
return mp_const_none;
}
self->callback = args[ARG_callback].u_obj;
self->dev.port = self->port;
self->dev.config.reload_mode = args[ARG_mode].u_int;
self->dev.config.period = (mp_uint_t)args[ARG_period].u_int * 1000UL;
self->dev.config.arg = self;
self->dev.config.cb = machine_timer_isr;
machine_timer_enable(self);
return mp_const_none;
}
STATIC mp_obj_t machine_timer_deinit(mp_obj_t self_in)
{
machine_timer_obj_t *self = MP_OBJ_TO_PTR(self_in);
timer_dev_t *tim = &self->dev;
aos_hal_timer_stop(tim);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(machine_timer_deinit_obj, machine_timer_deinit);
STATIC mp_obj_t machine_timer_init(size_t n_args, const mp_obj_t *args, mp_map_t *kw_args)
{
return machine_timer_init_helper(args[0], n_args - 1, args + 1, kw_args);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_KW(machine_timer_init_obj, 1, machine_timer_init);
STATIC mp_obj_t machine_timer_period(mp_obj_t self_in, mp_obj_t period)
{
machine_timer_obj_t *self = self_in;
if (self_in == NULL) {
mp_raise_OSError(MP_EINVAL);
return mp_const_none;
} else {
self->dev.config.period = mp_obj_get_int(period);
}
timer_config_t para = self->dev.config;
timer_dev_t *tim = &self->dev;
mp_int_t ret = aos_hal_timer_para_chg(tim, para);
return MP_OBJ_NEW_SMALL_INT(ret);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_2(machine_timer_period_obj, machine_timer_period);
STATIC mp_obj_t machine_timer_start(mp_obj_t self_in)
{
machine_timer_obj_t *self = self_in;
timer_dev_t *tim = &self->dev;
mp_int_t ret = aos_hal_timer_start(tim);
return MP_OBJ_NEW_SMALL_INT(ret);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(machine_timer_start_obj, machine_timer_start);
STATIC mp_obj_t machine_timer_stop(mp_obj_t self_in)
{
machine_timer_obj_t *self = self_in;
timer_dev_t *tim = &self->dev;
aos_hal_timer_stop(tim);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(machine_timer_stop_obj, machine_timer_stop);
STATIC mp_obj_t machine_timer_reload(mp_obj_t self_in)
{
machine_timer_obj_t *self = self_in;
timer_dev_t *tim = &self->dev;
mp_int_t ret = aos_timer_reload(tim);
return MP_OBJ_NEW_SMALL_INT(ret);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(machine_timer_reload_obj, machine_timer_reload);
STATIC const mp_rom_map_elem_t machine_timer_locals_dict_table[] = {
{ MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&machine_timer_deinit_obj) },
{ MP_ROM_QSTR(MP_QSTR_init), MP_ROM_PTR(&machine_timer_init_obj) },
{ MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&machine_timer_deinit_obj) },
{ MP_ROM_QSTR(MP_QSTR_start), MP_ROM_PTR(&machine_timer_start_obj) },
{ MP_ROM_QSTR(MP_QSTR_stop), MP_ROM_PTR(&machine_timer_stop_obj) },
{ MP_ROM_QSTR(MP_QSTR_period), MP_ROM_PTR(&machine_timer_period_obj) },
{ MP_ROM_QSTR(MP_QSTR_reload), MP_ROM_PTR(&machine_timer_reload_obj) },
{ MP_ROM_QSTR(MP_QSTR_ONE_SHOT), MP_ROM_INT(TIMER_MODE_ONESHOT) },
{ MP_ROM_QSTR(MP_QSTR_PERIODIC), MP_ROM_INT(TIMER_MODE_PERIODIC) },
};
STATIC MP_DEFINE_CONST_DICT(machine_timer_locals_dict, machine_timer_locals_dict_table);
const mp_obj_type_t machine_timer_type = {
{ &mp_type_type },
.name = MP_QSTR_Timer,
.print = machine_timer_print,
.make_new = machine_timer_make_new,
.locals_dict = (mp_obj_t)&machine_timer_locals_dict,
};
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/machine_timer.c | C | apache-2.0 | 6,544 |
/*
* Copyright (C) 2015-2021 Alibaba Group Holding Limited
*/
#include "modmachine.h"
#include "py/mphal.h"
#include "py/runtime.h"
#if 0
#include "driver/gpio.h"
#include "driver/touch_pad.h"
typedef struct _mtp_obj_t {
mp_obj_base_t base;
gpio_num_t gpio_id;
touch_pad_t touchpad_id;
} mtp_obj_t;
STATIC const mtp_obj_t touchpad_obj[] = {
{{&machine_touchpad_type}, GPIO_NUM_4, TOUCH_PAD_NUM0},
{{&machine_touchpad_type}, GPIO_NUM_0, TOUCH_PAD_NUM1},
{{&machine_touchpad_type}, GPIO_NUM_2, TOUCH_PAD_NUM2},
{{&machine_touchpad_type}, GPIO_NUM_15, TOUCH_PAD_NUM3},
{{&machine_touchpad_type}, GPIO_NUM_13, TOUCH_PAD_NUM4},
{{&machine_touchpad_type}, GPIO_NUM_12, TOUCH_PAD_NUM5},
{{&machine_touchpad_type}, GPIO_NUM_14, TOUCH_PAD_NUM6},
{{&machine_touchpad_type}, GPIO_NUM_27, TOUCH_PAD_NUM7},
{{&machine_touchpad_type}, GPIO_NUM_33, TOUCH_PAD_NUM8},
{{&machine_touchpad_type}, GPIO_NUM_32, TOUCH_PAD_NUM9},
};
STATIC mp_obj_t mtp_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw,
const mp_obj_t *args) {
mp_arg_check_num(n_args, n_kw, 1, 1, true);
gpio_num_t pin_id = machine_pin_get_id(args[0]);
const mtp_obj_t *self = NULL;
for (int i = 0; i < MP_ARRAY_SIZE(touchpad_obj); i++) {
if (pin_id == touchpad_obj[i].gpio_id) {
self = &touchpad_obj[i];
break;
}
}
if (!self) {
mp_raise_ValueError(MP_ERROR_TEXT("invalid pin for touchpad"));
}
static int initialized = 0;
if (!initialized) {
touch_pad_init();
touch_pad_set_fsm_mode(TOUCH_FSM_MODE_TIMER);
initialized = 1;
}
esp_err_t err = touch_pad_config(self->touchpad_id, 0);
if (err == ESP_OK) {
return MP_OBJ_FROM_PTR(self);
}
mp_raise_ValueError(MP_ERROR_TEXT("Touch pad error"));
}
STATIC mp_obj_t mtp_config(mp_obj_t self_in, mp_obj_t value_in) {
mtp_obj_t *self = self_in;
uint16_t value = mp_obj_get_int(value_in);
esp_err_t err = touch_pad_config(self->touchpad_id, value);
if (err == ESP_OK) {
return mp_const_none;
}
mp_raise_ValueError(MP_ERROR_TEXT("Touch pad error"));
}
MP_DEFINE_CONST_FUN_OBJ_2(mtp_config_obj, mtp_config);
STATIC mp_obj_t mtp_read(mp_obj_t self_in) {
mtp_obj_t *self = self_in;
uint16_t value;
esp_err_t err = touch_pad_read(self->touchpad_id, &value);
if (err == ESP_OK) {
return MP_OBJ_NEW_SMALL_INT(value);
}
mp_raise_ValueError(MP_ERROR_TEXT("Touch pad error"));
}
MP_DEFINE_CONST_FUN_OBJ_1(mtp_read_obj, mtp_read);
STATIC const mp_rom_map_elem_t mtp_locals_dict_table[] = {
// instance methods
{ MP_ROM_QSTR(MP_QSTR_config), MP_ROM_PTR(&mtp_config_obj) },
{ MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&mtp_read_obj) },
};
STATIC MP_DEFINE_CONST_DICT(mtp_locals_dict, mtp_locals_dict_table);
const mp_obj_type_t machine_touchpad_type = {
{ &mp_type_type },
.name = MP_QSTR_TouchPad,
.make_new = mtp_make_new,
.locals_dict = (mp_obj_t)&mtp_locals_dict,
};
#endif
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/machine_touchpad.c | C | apache-2.0 | 3,059 |
/*
* Copyright (C) 2015-2021 Alibaba Group Holding Limited
*/
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include "aos_hal_uart.h"
#include "modmachine.h"
#include "py/mperrno.h"
#include "py/runtime.h"
#include "py/stream.h"
#include "ulog/ulog.h"
#define LOG_TAG "machine_uart"
enum {
UART_NUM_0,
UART_NUM_1,
UART_NUM_2,
UART_NUM_3,
UART_NUM_MAX
};
enum {
e_DATA_WIDTH_5BIT = 5,
e_DATA_WIDTH_6BIT,
e_DATA_WIDTH_7BIT,
e_DATA_WIDTH_8BIT,
e_DATA_WIDTH_9BIT
};
enum {
e_STOP_BITS_1 = 1,
e_STOP_BITS_2
};
typedef struct _machine_uart_obj_t {
mp_obj_base_t base;
uint8_t uart_num;
bool uart_inited;
uart_dev_t dev;
uint16_t timeout; // timeout waiting for first char (in ms)
uint16_t timeout_char; // timeout waiting between chars (in ms)
} machine_uart_obj_t;
STATIC const char *_parity_name[] = { "None", "Odd", "Even" };
STATIC const char *_flowctrl_name[] = { "Disable", "CTS", "RTS", "CTS_RTS" };
STATIC const char *_mode_name[] = { "Tx", "Rx", "Tx_Rx" };
STATIC const uint8_t _bits[] = { e_DATA_WIDTH_5BIT, e_DATA_WIDTH_6BIT, e_DATA_WIDTH_7BIT, e_DATA_WIDTH_8BIT,
e_DATA_WIDTH_9BIT };
const mp_obj_type_t machine_uart_type;
/******************************************************************************/
// MicroPython bindings for UART
STATIC void machine_uart_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind)
{
machine_uart_obj_t *self = MP_OBJ_TO_PTR(self_in);
mp_printf(print,
"UART(%u, baudrate=%u, bits=%u, parity=%s, stop=%u, "
"flow_ctrl=%s, mode=%s, timeout=%u, timeout_char=%u)",
self->uart_num, self->dev.config.baud_rate, _bits[self->dev.config.data_width],
_parity_name[self->dev.config.parity], self->dev.config.stop_bits,
_flowctrl_name[self->dev.config.flow_control], _mode_name[self->dev.config.mode], self->timeout,
self->timeout_char);
}
STATIC void machine_uart_init_helper(machine_uart_obj_t *self, size_t n_args, const mp_obj_t *pos_args,
mp_map_t *kw_args)
{
enum {
ARG_baudrate,
ARG_bits,
ARG_parity,
ARG_stop,
ARG_tx,
ARG_rx,
ARG_rts,
ARG_cts,
ARG_txbuf,
ARG_rxbuf,
ARG_timeout,
ARG_timeout_char,
ARG_invert
};
static const mp_arg_t allowed_args[] = {
{ MP_QSTR_baudrate, MP_ARG_INT, { .u_int = 115200 } },
{ MP_QSTR_bits, MP_ARG_INT, { .u_int = e_DATA_WIDTH_8BIT } },
{ MP_QSTR_parity, MP_ARG_OBJ, { .u_int = NO_PARITY } },
{ MP_QSTR_stop, MP_ARG_INT, { .u_int = e_STOP_BITS_1 } },
{ MP_QSTR_tx, MP_ARG_KW_ONLY | MP_ARG_INT, { .u_int = -1 } },
{ MP_QSTR_rx, MP_ARG_KW_ONLY | MP_ARG_INT, { .u_int = -1 } },
{ MP_QSTR_rts, MP_ARG_KW_ONLY | MP_ARG_INT, { .u_int = 0 } },
{ MP_QSTR_cts, MP_ARG_KW_ONLY | MP_ARG_INT, { .u_int = 0 } },
{ MP_QSTR_txbuf, MP_ARG_KW_ONLY | MP_ARG_INT, { .u_int = -1 } },
{ MP_QSTR_rxbuf, MP_ARG_KW_ONLY | MP_ARG_INT, { .u_int = -1 } },
{ MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_INT, { .u_int = 0 } },
{ MP_QSTR_timeout_char, MP_ARG_KW_ONLY | MP_ARG_INT, { .u_int = 0 } },
{ MP_QSTR_invert, MP_ARG_KW_ONLY | MP_ARG_INT, { .u_int = 0 } },
};
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
uart_dev_t *dev = &self->dev;
// wait for all data to be transmitted before changing settings
// TODO
// set baudrate
mp_int_t baudrate = args[ARG_baudrate].u_int;
if (baudrate <= 0) {
mp_raise_ValueError(MP_ERROR_TEXT("baud rate error"));
} else {
dev->config.baud_rate = baudrate;
}
// set flow_control
mp_uint_t rts = args[ARG_rts].u_int;
mp_uint_t cts = args[ARG_cts].u_int;
if (rts && cts) {
dev->config.flow_control = FLOW_CONTROL_CTS_RTS;
} else if (cts) {
dev->config.flow_control = FLOW_CONTROL_CTS;
} else if (rts) {
dev->config.flow_control = FLOW_CONTROL_RTS;
} else {
dev->config.flow_control = FLOW_CONTROL_DISABLED;
}
// set data bits
uint8_t data_width = args[ARG_bits].u_int;
switch (data_width) {
case e_DATA_WIDTH_5BIT:
dev->config.data_width = DATA_WIDTH_5BIT;
break;
case e_DATA_WIDTH_6BIT:
dev->config.data_width = DATA_WIDTH_6BIT;
break;
case e_DATA_WIDTH_7BIT:
dev->config.data_width = DATA_WIDTH_7BIT;
break;
case e_DATA_WIDTH_8BIT:
dev->config.data_width = DATA_WIDTH_8BIT;
break;
case e_DATA_WIDTH_9BIT:
dev->config.data_width = DATA_WIDTH_9BIT;
break;
default:
mp_raise_ValueError(MP_ERROR_TEXT("invalid data bits"));
}
// set parity
if (args[ARG_parity].u_obj != MP_OBJ_NULL) {
if (args[ARG_parity].u_obj == mp_const_none) {
dev->config.parity = NO_PARITY;
} else {
mp_int_t parity = mp_obj_get_int(args[ARG_parity].u_obj);
if (parity & 1) {
dev->config.parity = ODD_PARITY;
} else {
dev->config.parity = EVEN_PARITY;
}
}
}
// set stop bits
uint8_t stop_bits = args[ARG_stop].u_int;
switch (stop_bits) {
case e_STOP_BITS_1:
dev->config.stop_bits = STOP_BITS_1;
break;
case e_STOP_BITS_2:
dev->config.stop_bits = STOP_BITS_2;
break;
default:
mp_raise_ValueError(MP_ERROR_TEXT("invalid stop bits"));
}
// set timeout
self->timeout = args[ARG_timeout].u_int;
// set timeout_char
// make sure it is at least as long as a whole character (13 bits to be
// safe)
self->timeout_char = args[ARG_timeout_char].u_int;
mp_uint_t min_timeout_char = 13000 / baudrate + 1;
if (self->timeout_char < min_timeout_char) {
self->timeout_char = min_timeout_char;
}
}
STATIC mp_obj_t machine_uart_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args)
{
mp_arg_check_num(n_args, n_kw, 1, MP_OBJ_FUN_ARGS_MAX, true);
// get uart id
mp_int_t uart_num = mp_obj_get_int(args[0]);
if (uart_num < 0 || uart_num >= UART_NUM_MAX) {
mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("UART(%d) does not exist"), uart_num);
}
// Attempts to use UART0 from Python has resulted in all sorts of fun
// errors.
// FIXME: UART0 is disabled for now.
if (uart_num == UART_NUM_0) {
mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("UART(%d) is disabled (dedicated to REPL)"), uart_num);
}
// create instance
machine_uart_obj_t *self = m_new_obj(machine_uart_obj_t);
self->base.type = &machine_uart_type;
self->dev.port = uart_num;
self->dev.config.baud_rate = 115200;
self->dev.config.data_width = DATA_WIDTH_8BIT;
self->dev.config.parity = NO_PARITY;
self->dev.config.stop_bits = STOP_BITS_1;
self->dev.config.flow_control = FLOW_CONTROL_DISABLED;
self->dev.config.mode = MODE_TX_RX;
self->dev.priv = NULL;
self->timeout = 0;
self->timeout_char = 0;
self->uart_inited = false;
mp_map_t kw_args;
mp_map_init_fixed_table(&kw_args, n_kw, args + n_args);
machine_uart_init_helper(self, n_args - 1, args + 1, &kw_args);
return MP_OBJ_FROM_PTR(self);
}
STATIC mp_obj_t machine_uart_init(size_t n_args, const mp_obj_t *args, mp_map_t *kw_args)
{
machine_uart_init_helper(args[0], n_args - 1, args + 1, kw_args);
return mp_const_none;
}
MP_DEFINE_CONST_FUN_OBJ_KW(machine_uart_init_obj, 1, machine_uart_init);
STATIC mp_obj_t machine_uart_deinit(mp_obj_t self_in)
{
machine_uart_obj_t *self = MP_OBJ_TO_PTR(self_in);
if (self->uart_inited == true) {
aos_hal_uart_finalize(&self->dev);
}
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(machine_uart_deinit_obj, machine_uart_deinit);
STATIC mp_obj_t machine_uart_any(mp_obj_t self_in)
{
machine_uart_obj_t *self = MP_OBJ_TO_PTR(self_in);
mp_raise_NotImplementedError(MP_ERROR_TEXT("attenuation not supported"));
return MP_OBJ_NEW_SMALL_INT(0);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(machine_uart_any_obj, machine_uart_any);
STATIC mp_obj_t machine_uart_sendbreak(mp_obj_t self_in)
{
machine_uart_obj_t *self = MP_OBJ_TO_PTR(self_in);
mp_raise_NotImplementedError(MP_ERROR_TEXT("attenuation not supported"));
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(machine_uart_sendbreak_obj, machine_uart_sendbreak);
STATIC const mp_rom_map_elem_t machine_uart_locals_dict_table[] = {
{ MP_ROM_QSTR(MP_QSTR_init), MP_ROM_PTR(&machine_uart_init_obj) },
{ MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&machine_uart_deinit_obj) },
{ MP_ROM_QSTR(MP_QSTR_any), MP_ROM_PTR(&machine_uart_any_obj) },
{ MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&mp_stream_read_obj) },
{ MP_ROM_QSTR(MP_QSTR_readline), MP_ROM_PTR(&mp_stream_unbuffered_readline_obj) },
{ MP_ROM_QSTR(MP_QSTR_readinto), MP_ROM_PTR(&mp_stream_readinto_obj) },
{ MP_ROM_QSTR(MP_QSTR_write), MP_ROM_PTR(&mp_stream_write_obj) },
{ MP_ROM_QSTR(MP_QSTR_sendbreak), MP_ROM_PTR(&machine_uart_sendbreak_obj) },
};
STATIC MP_DEFINE_CONST_DICT(machine_uart_locals_dict, machine_uart_locals_dict_table);
STATIC mp_int_t uart_init(machine_uart_obj_t *self)
{
// init uart if not
if (self->uart_inited == false) {
int status = aos_hal_uart_init(&self->dev);
if (status != 0) {
LOGE(LOG_TAG, "Failed to init uart, status = %d\n", status);
return -status;
} else {
self->uart_inited = true;
}
}
return 0;
}
STATIC mp_uint_t machine_uart_read(mp_obj_t self_in, void *buf_in, mp_uint_t size, int *errcode)
{
machine_uart_obj_t *self = MP_OBJ_TO_PTR(self_in);
// make sure we want at least 1 char
if (size == 0) {
return 0;
}
int status = uart_init(self);
if (status != 0) {
return status;
}
mp_uint_t bytes_read = 0;
MP_THREAD_GIL_EXIT();
status = aos_hal_uart_recv_II(&self->dev, buf_in, size, &bytes_read, self->timeout);
MP_THREAD_GIL_ENTER();
if (status != 0) {
LOGW(LOG_TAG, "uart read failed with status=%d", status);
*errcode = MP_EAGAIN;
return MP_STREAM_ERROR;
}
return bytes_read;
}
STATIC mp_uint_t machine_uart_write(mp_obj_t self_in, const void *buf_in, mp_uint_t size, int *errcode)
{
machine_uart_obj_t *self = MP_OBJ_TO_PTR(self_in);
// init uart if not
int status = uart_init(self);
if (status != 0) {
return status;
}
MP_THREAD_GIL_EXIT();
status = aos_hal_uart_send(&self->dev, buf_in, size, self->timeout);
MP_THREAD_GIL_ENTER();
if (status != 0) {
*errcode = MP_EAGAIN;
return MP_STREAM_ERROR;
}
// return number of bytes written
return size;
}
STATIC mp_uint_t machine_uart_ioctl(mp_obj_t self_in, mp_uint_t request, uintptr_t arg, int *errcode)
{
machine_uart_obj_t *self = self_in;
mp_uint_t ret;
if (request == MP_STREAM_POLL) {
mp_uint_t flags = arg;
ret = 0;
size_t rxbufsize = 0;
// uart_get_buffered_data_len(self->uart_num, &rxbufsize);
if ((flags & MP_STREAM_POLL_RD) && rxbufsize > 0) {
ret |= MP_STREAM_POLL_RD;
}
if ((flags & MP_STREAM_POLL_WR) && 1) {
ret |= MP_STREAM_POLL_WR;
}
} else {
*errcode = MP_EINVAL;
ret = MP_STREAM_ERROR;
}
return ret;
}
STATIC const mp_stream_p_t uart_stream_p = {
.read = machine_uart_read,
.write = machine_uart_write,
.ioctl = machine_uart_ioctl,
.is_text = false,
};
const mp_obj_type_t machine_uart_type = {
{ &mp_type_type },
.name = MP_QSTR_UART,
.print = machine_uart_print,
.make_new = machine_uart_make_new,
.getiter = mp_identity_getiter,
.iternext = mp_stream_unbuffered_iter,
.protocol = &uart_stream_p,
.locals_dict = (mp_obj_dict_t *)&machine_uart_locals_dict,
};
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/machine_uart.c | C | apache-2.0 | 12,277 |
/*
* Copyright (C) 2015-2021 Alibaba Group Holding Limited
*/
#include <string.h>
#include "aos_hal_wdg.h"
#include "py/nlr.h"
#include "py/obj.h"
#include "py/runtime.h"
#include "ulog/ulog.h"
#define LOG_TAG "machine-wdt"
#define DEFAULT_WDT_TIMEOUT (5000)
const mp_obj_type_t machine_wdt_type;
typedef struct _machine_wdt_obj_t {
mp_obj_base_t base;
wdg_dev_t dev;
} machine_wdt_obj_t;
STATIC machine_wdt_obj_t wdt_default = { { &machine_wdt_type }, { 0, { DEFAULT_WDT_TIMEOUT }, NULL } };
STATIC mp_obj_t machine_wdt_make_new(const mp_obj_type_t *type_in, size_t n_args, size_t n_kw, const mp_obj_t *all_args)
{
enum {
ARG_id,
ARG_timeout
};
static const mp_arg_t allowed_args[] = { { MP_QSTR_id, MP_ARG_INT, { .u_int = 0 } },
{ MP_QSTR_timeout, MP_ARG_INT, { .u_int = DEFAULT_WDT_TIMEOUT } } };
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
mp_arg_parse_all_kw_array(n_args, n_kw, all_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
if (args[ARG_id].u_int != 0) {
mp_raise_ValueError(NULL);
}
// Convert milliseconds to seconds
args[ARG_timeout].u_int /= 1000;
if (args[ARG_timeout].u_int <= 0) {
mp_raise_ValueError(MP_ERROR_TEXT("WDT timeout too short"));
}
wdg_dev_t *dev = &(wdt_default.dev);
wdg_config_t cfg = { 0 };
cfg.timeout = args[ARG_timeout].u_int;
dev->config = cfg;
mp_int_t rs_code = aos_hal_wdg_init(dev);
if (rs_code != 0) {
mp_raise_OSError(rs_code);
}
return &wdt_default;
}
STATIC mp_obj_t machine_wdt_feed(mp_obj_t self_in)
{
machine_wdt_obj_t *self = (machine_wdt_obj_t *)self_in;
aos_hal_wdg_reload(&self->dev);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(machine_wdt_feed_obj, machine_wdt_feed);
STATIC mp_obj_t machine_wdt_deinit(mp_obj_t self_in)
{
machine_wdt_obj_t *self = (machine_wdt_obj_t *)self_in;
mp_int_t status = aos_hal_wdg_finalize(&self->dev);
return MP_OBJ_NEW_SMALL_INT(status);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(machine_wdt_deinit_obj, machine_wdt_deinit);
STATIC const mp_rom_map_elem_t machine_wdt_locals_dict_table[] = {
{ MP_ROM_QSTR(MP_QSTR_feed), MP_ROM_PTR(&machine_wdt_feed_obj) },
{ MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&machine_wdt_deinit_obj) },
};
STATIC MP_DEFINE_CONST_DICT(machine_wdt_locals_dict, machine_wdt_locals_dict_table);
const mp_obj_type_t machine_wdt_type = {
{ &mp_type_type },
.name = MP_QSTR_WDT,
.make_new = machine_wdt_make_new,
.locals_dict = (mp_obj_t)&machine_wdt_locals_dict,
};
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/machine_wdt.c | C | apache-2.0 | 2,638 |
/*
* Copyright (C) 2015-2020 Alibaba Group Holding Limited
*/
#include <aos/errno.h>
#include <aos/kernel.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include "amp_task.h"
#include "aos/init.h"
#include "aos/vfs.h"
#include "aos_hal_uart.h"
#include "board.h"
#include "board_mgr.h"
#include "cJSON.h"
#include "mpstdinport.h"
#include "netmgr.h"
#include "py/compile.h"
#include "py/gc.h"
#include "py/mperrno.h"
#include "py/mphal.h"
#include "py/repl.h"
#include "py/runtime.h"
#include "py/stackctrl.h"
#include "py_defines.h"
#include "shared/runtime/pyexec.h"
#include "sys/stat.h"
#include "ulog/ulog.h"
#if AOS_COMP_CLI
#include "aos/cli.h"
#endif
#include "haas_main.h"
#define LOG_TAG "haas_main"
static int8_t *stack_top = NULL;
static bool isPythonRunning = false;
static uint32_t stack_size = 1024;
#if MICROPY_ENABLE_GC
static int8_t *heap = NULL;
#ifndef MICROPY_GC_HEAP_SIZE
#define MICROPY_GC_HEAP_SIZE (1024 * 64)
#endif
#endif
static mpy_thread_args *alloc_mpy_thread_args(int32_t argc, int8_t **argv)
{
mpy_thread_args *temp_args = (mpy_thread_args *)calloc(1, sizeof(mpy_thread_args));
if (temp_args == NULL) {
LOGE(LOG_TAG, "%s;malloc mpy_thread_args failed\n", __func__);
return NULL;
}
if (argc == 1) {
temp_args->is_repl_mode = true;
} else {
temp_args->is_repl_mode = false;
}
temp_args->argc = argc;
temp_args->argv = (int8_t **)calloc(1, sizeof(int8_t *) * temp_args->argc);
if (temp_args->argv == NULL) {
LOGE(LOG_TAG, "%s:temp_args->argv alloc memory failed\n", __func__);
free(temp_args);
return NULL;
}
for (int32_t i = 0; i < argc; i++) {
temp_args->argv[i] = strdup(argv[i]);
}
return temp_args;
}
static int32_t free_mpy_thread_args(mpy_thread_args *args)
{
if (args == NULL) {
LOGE(LOG_TAG, "args is illegal\n");
return -1;
}
for (int32_t i = 0; i < args->argc; i++) {
if (args->argv[i] != NULL) {
free(args->argv[i]);
}
}
free(args->argv);
free(args);
return 0;
}
static bool is_file_exist(const int8_t *path)
{
if (path == NULL) {
LOGE(LOG_TAG, "File path null\n");
return false;
}
FILE *fd = fopen(path, "r");
if (fd != NULL) {
fclose(fd);
return true;
}
return false;
}
static uint8_t *is_mainpy_exist()
{
/* check whether main/pyamp/main.py */
FILE *fd = fopen(AMP_PY_ENTRY_DEFAULE, "r");
if (fd != NULL) {
fclose(fd);
return AMP_PY_ENTRY_DEFAULE;
}
fd = fopen(AMP_PY_ENTRY_BAK, "r");
if (fd != NULL) {
fclose(fd);
return AMP_PY_ENTRY_BAK;
}
fd = fopen(MP_PY_ENTRY_BAK, "r");
if (fd != NULL) {
fclose(fd);
return MP_PY_ENTRY_BAK;
}
return NULL;
}
static void net_init()
{
#define WIFI_DEV_PATH "/dev/wifi0"
int8_t *wificonf = MP_FS_ROOT_DIR "/wifi.conf";
if (is_file_exist(wificonf) == true) {
event_service_init(NULL);
netmgr_service_init(NULL);
netmgr_set_auto_reconnect(0, true);
netmgr_wifi_set_auto_save_ap(true);
netmgr_add_dev(WIFI_DEV_PATH);
netmgr_hdl_t hdl = netmgr_get_dev(WIFI_DEV_PATH);
} else {
// need init event service because of eth net
event_service_init(NULL);
netmgr_service_init(NULL);
netmgr_set_auto_reconnect(0, true);
netmgr_wifi_set_auto_save_ap(true);
}
}
#include "extmod/vfs.h"
#include "extmod/vfs_posix.h"
// Try to mount the data on "/data" and chdir to it for the boot-up directory.
static int32_t mount_fs(int8_t *mount_point_str)
{
mp_obj_t mount_point = mp_obj_new_str(mount_point_str, strlen(mount_point_str));
mp_obj_t bdev = mp_type_vfs_posix.make_new(&mp_type_vfs_posix, 0, 0, NULL);
int32_t ret = mp_vfs_mount_and_chdir_protected(bdev, mount_point);
if (ret != 0) {
printf("mount_fs failed with mount_point: %s\n", mount_point_str);
return -MP_ENOENT;
}
return 0;
}
static void py_engine_mainloop(void *p)
{
mpy_thread_args *args = (mpy_thread_args *)p;
if (args == NULL) {
LOGE(LOG_TAG, "%s:args is illegal\n", __func__);
return;
}
int32_t ret = mpy_init(args);
if (ret) {
LOGE(LOG_TAG, "%s:mpy_init failed, ret=%d\n", __func__, ret);
} else {
/* Suspend CLI to make sure REPL use UART exclusively */
aos_cli_suspend();
isPythonRunning = true;
mpy_run(args->argc, args->argv);
/* Resume CLI after REPL */
aos_cli_resume();
}
free_mpy_thread_args(args);
mpy_deinit();
isPythonRunning = false;
}
static void py_engine_task(void *p)
{
py_task_init();
while (1) {
/* loop for asynchronous operation */
if (py_task_yield(200) == 1) {
printf("pyengine task yield exit! \r\n");
break;
}
}
aos_task_exit(0);
}
// #if PY_CHANNEL_ENABLE
// static void network_func(void *argv)
// {
// while (!aos_get_network_status()) {
// aos_msleep(1000);
// }
// //py_app_management_center_init();
// extern int pyamp_app_upgrade(char *url);
// amp_otaput_init(pyamp_app_upgrade);
// aos_task_exit(0);
// return;
// }
// #endif
static void python_entry(int32_t argc, int8_t **argv)
{
if (isPythonRunning == true) {
printf(" **************************************************** \r\n");
printf(" ** Python is running, cannot start another engine ** \r\n");
printf(" **************************************************** \r\n");
return;
}
printf(" Welcome to MicroPython \n");
aos_task_t engine_entry = NULL;
mpy_thread_args *args = alloc_mpy_thread_args(argc, argv);
int32_t ret =
aos_task_new_ext(&engine_entry, "py_engine", py_engine_mainloop, args, 1024 * 20, AOS_DEFAULT_APP_PRI);
if (ret != 0) {
LOGE(LOG_TAG, "py_engine_mainloop task creat failed!");
return;
}
}
char *board_get_json_buff(const char *json_path);
static aos_log_level_t get_logLevel()
{
int32_t ret = -1;
int8_t logLevelStr[16] = { 0 };
int8_t *data_root_path = AMP_FS_ROOT_DIR "/board.json";
int8_t *board_json_path = MP_FS_ROOT_DIR "/python-apps/driver/board.json";
FILE *json_fd = fopen(data_root_path, "r");
if (json_fd != NULL) {
fclose(json_fd);
board_json_path = data_root_path;
}
int8_t *json_buff = board_get_json_buff(board_json_path);
if (NULL == json_buff) {
goto debugLevel_kv; /* get debugLevel from kv */
}
cJSON *root = cJSON_Parse(json_buff);
if (NULL == root) {
goto debugLevel_kv; /* get debugLevel from kv */
}
cJSON *debug = cJSON_GetObjectItem(root, APP_CONFIG_DEBUG);
if (debug != NULL) {
if (!cJSON_IsString(debug)) {
goto debugLevel_kv;
} else {
strcpy(logLevelStr, debug->valuestring);
goto debugLevel_parser;
}
}
debugLevel_kv:
if (json_buff != NULL) {
aos_free(json_buff);
}
int32_t len = sizeof(logLevelStr);
ret = aos_kv_get(APP_CONFIG_DEBUG, logLevelStr, &len);
if (ret != 0) {
uint8_t *set_value = "ERROR";
aos_kv_set(APP_CONFIG_DEBUG, set_value, strlen(set_value), 1);
strcpy(logLevelStr, set_value);
}
debugLevel_parser:
if (strcmp(logLevelStr, "DEBUG") == 0) {
return AOS_LL_DEBUG;
} else if (strcmp(logLevelStr, "INFO") == 0) {
return AOS_LL_INFO;
} else if (strcmp(logLevelStr, "WARN") == 0) {
return AOS_LL_WARN;
} else if (strcmp(logLevelStr, "ERROR") == 0) {
return AOS_LL_ERROR;
} else if (strcmp(logLevelStr, "FATAL") == 0) {
return AOS_LL_FATAL;
} else if (strcmp(logLevelStr, "NONE") == 0) {
return AOS_LL_NONE;
}
return AOS_LL_ERROR;
}
void haas_main(int32_t argc, int8_t **argv)
{
int32_t ret = -1;
#if PY_BOOT_ENABLE
aos_cli_suspend();
pyamp_boot_main();
aos_cli_resume();
#endif
#if PY_BUILD_KV
/* kv module init */
ret = kv_init();
if (ret != 0) {
LOGE(LOG_TAG, "kv init failed!");
return;
}
#endif
/* ulog module init */
ulog_init();
aos_log_level_t log_level = get_logLevel();
aos_set_log_level(log_level);
/* net init */
// net_init();
aos_task_t engine_task;
ret = aos_task_new_ext(&engine_task, "py_engine_task", py_engine_task, NULL, 1024 * 8, AOS_DEFAULT_APP_PRI);
if (ret != 0) {
LOGE(LOG_TAG, "pyengine task creat failed!");
return;
}
// #if PY_CHANNEL_ENABLE
// aos_task_t network_task;
// /* network start */
// ret = aos_task_new_ext(&network_task, "mpy_network", network_func, NULL, 1024 * 8, AOS_DEFAULT_APP_PRI);
// if (ret != 0) {
// LOGE(LOG_TAG, "network task creat failed!");
// return ret;
// }
// #endif
/* Check whether we have main.py to execute */
// defalut entry python engine
// uint8_t *path = is_mainpy_exist();
// if (path != NULL) {
// uint8_t *argv[2] = { "python", path };
// python_entry(2, &argv);
// }
uint8_t *param[1] = { "python" };
python_entry(1, ¶m);
}
static void handle_unzip_cmd(int32_t argc, int8_t **argv)
{
int8_t *zippath;
int8_t *destpath;
int32_t ret = 0;
if (argc < 2) {
LOGE(LOG_TAG, "Error params,Usage: unzip /data/src.zip /sdcard \r\n");
return;
}
if (argc == 2) {
destpath = "/data";
} else {
destpath = argv[2];
}
zippath = argv[1];
ret = miniUnzip(zippath, destpath);
if (ret) {
LOGE(LOG_TAG, "unzip failed ,errno is %d \r\n", ret);
} else {
LOGD(LOG_TAG, "unzip succeed \r\n");
}
}
#if MICROPY_ENABLE_COMPILER
void do_str(const int8_t *src, mp_parse_input_kind_t input_kind)
{
nlr_buf_t nlr;
if (nlr_push(&nlr) == 0) {
mp_lexer_t *lex = mp_lexer_new_from_str_len(MP_QSTR__lt_stdin_gt_, src, strlen(src), 0);
qstr source_name = lex->source_name;
mp_parse_tree_t parse_tree = mp_parse(lex, input_kind);
mp_obj_t module_fun = mp_compile(&parse_tree, source_name, true);
mp_call_function_0(module_fun);
nlr_pop();
} else {
// uncaught exception
mp_obj_print_exception(&mp_plat_print, (mp_obj_t)nlr.ret_val);
}
}
#endif
int32_t mpy_init(mpy_thread_args *args)
{
int32_t ret = -1;
mp_stdin_init(MP_REPL_UART_PORT, MP_REPL_UART_BAUDRATE);
#if MICROPY_PY_THREAD
void *stack_addr = mp_sal_get_stack_addr();
stack_size = mp_sal_get_stack_size();
mp_thread_init(stack_addr, stack_size);
#endif
#if MICROPY_ENABLE_GC
heap = (int8_t *)malloc(MICROPY_GC_HEAP_SIZE);
if (NULL == heap) {
LOGE(LOG_TAG, "mpy_init: heap alloc fail!\r\n");
return -1;
}
#endif
return 0;
}
int32_t mpy_deinit(void)
{
// need relese python run mem
#if MICROPY_ENABLE_GC
if (NULL != heap) {
free(heap);
heap == NULL;
}
#endif
mp_stdin_deinit();
}
static void set_sys_argv(int8_t *argv[], int32_t argc, int32_t start_arg)
{
for (int32_t i = start_arg; i < argc; i++) {
mp_obj_list_append(mp_sys_argv, MP_OBJ_NEW_QSTR(qstr_from_str(argv[i])));
}
}
int32_t is_download_mode(uint32_t wait_time_ms)
{
int32_t ret = 0;
int32_t c = 0;
int64_t now_time = 0;
int64_t begin_time = aos_now_ms();
do {
int32_t c = ringbuf_get(&stdin_ringbuf);
if (c == '\x03') {
ret = 1;
break;
}
now_time = aos_now_ms();
uint32_t time = now_time - begin_time;
if (time >= wait_time_ms) {
ret = 0;
break;
}
pyamp_boot_delay(1);
} while (1);
return ret;
}
int32_t mpy_run(int32_t argc, int8_t *argv[])
{
int32_t ret = 0;
int32_t mode = 0;
soft_reset:
mp_stack_set_top(stack_top);
// adjust the stack_size to provide room to recover from hitting the
// limit
#if MICROPY_STACK_CHECK
mp_stack_ctrl_init();
mp_stack_set_limit(stack_size * sizeof(cpu_stack_t) - 1024);
#endif
// reinit gc
#if MICROPY_ENABLE_GC
gc_init(heap, heap + MICROPY_GC_HEAP_SIZE);
#endif
mp_init();
#if MICROPY_VFS_POSIX
{
// Mount the host FS at the root of our internal VFS
ret = mount_fs("/");
if (ret != 0) {
printf(" !!!!!!!! %s, %d, faild to mount fs !!!!!!!!\n", __func__, __LINE__);
}
MP_STATE_VM(vfs_cur) = MP_STATE_VM(vfs_mount_table);
}
#endif
/*set default mp_sys_path*/
mp_obj_list_init(mp_sys_path, 0);
mp_obj_list_append(mp_sys_path,
MP_OBJ_NEW_QSTR(MP_QSTR_)); // current dir (or base dir of the script)
// add /data/pyamp to system path
int8_t *path = MP_FS_ROOT_DIR "/pyamp";
mp_obj_list_append(mp_sys_path, mp_obj_new_str_via_qstr(path, strlen(path)));
// add /data/lib to system path
path = MP_FS_ROOT_DIR "/lib";
mp_obj_list_append(mp_sys_path, mp_obj_new_str_via_qstr(path, strlen(path)));
// add /sdcard/pyamp to system path
path = MP_FS_EXT_ROOT_DIR "/pyamp";
mp_obj_list_append(mp_sys_path, mp_obj_new_str_via_qstr(path, strlen(path)));
// add /sdcard/lib to system path
path = MP_FS_EXT_ROOT_DIR "/lib";
mp_obj_list_append(mp_sys_path, mp_obj_new_str_via_qstr(path, strlen(path)));
mp_obj_list_init(mp_sys_argv, 0);
// #if 0
// mode = is_download_mode(300); /* Only available on HaaS506 */
// #endif
// if (argc >= 2 && mode == 0) {
// int8_t *filename = argv[1];
// int8_t filepath[256] = { 0 };
// if (filename[0] != '/') {
// getcwd(filepath, sizeof(filepath));
// strcat(filepath, "/");
// strcat(filepath, filename);
// } else {
// strcpy(filepath, filename);
// }
// int8_t *p = strrchr(filepath, '/');
// size_t len = 0;
// mp_obj_t *path_items = NULL;
// mp_obj_list_get(mp_sys_path, &len, &path_items);
// if (p >= filepath) {
// path_items[0] = mp_obj_new_str_via_qstr(filepath, p - filepath);
// } else {
// path_items[0] = mp_obj_new_str_via_qstr(filepath, filepath - p);
// }
// set_sys_argv(argv, argc, 1);
// if (filepath != NULL) {
// pyexec_file(filepath);
// }
// }
// run boot-up scripts
// pyexec_frozen_module("_boot.py");
// do not delete this message, haas studio need use this message judge python status
// printf(" ==== python execute bootpy ====\n");
pyexec_file_if_exists("/boot.py");
if (pyexec_mode_kind == PYEXEC_MODE_FRIENDLY_REPL) {
char *path = is_mainpy_exist();
if (path != NULL) {
// do not delete this message, haas studio need use this message judge python status
// printf(" ==== python execute from %s ====\n", path);
int ret = pyexec_file_if_exists(path);
if (ret & PYEXEC_FORCED_EXIT) {
goto soft_reset_exit;
#if 1
} else if (ret & PYEXEC_FORCED_QUIT) {
goto soft_quit_exit;
#endif
}
}
}
{
for (;;) {
if (pyexec_mode_kind == PYEXEC_MODE_RAW_REPL) {
ret = pyexec_raw_repl();
#if MICROPY_PY_AOS_QUIT
if (ret == PYEXEC_FORCED_QUIT) {
goto soft_quit_exit;
}
#endif
if (ret != 0) {
break;
}
} else {
ret = pyexec_friendly_repl();
#if MICROPY_PY_AOS_QUIT
if (ret == PYEXEC_FORCED_QUIT) {
goto soft_quit_exit;
}
#endif
if (ret != 0) {
break;
}
}
}
}
soft_reset_exit:
mp_hal_stdout_tx_str("MPY: soft reboot\r\n");
mp_deinit();
#if MICROPY_PY_AOS_QUIT
goto soft_reset;
#endif
soft_quit_exit:
return 0;
}
MP_WEAK mp_lexer_t *mp_lexer_new_from_file(const char *filename)
{
mp_raise_OSError(MP_ENOENT);
}
void nlr_jump_fail(void *val)
{
while (1)
;
}
void NORETURN __fatal_error(const int8_t *msg)
{
while (1)
;
}
#ifndef NDEBUG
void MP_WEAK __assert_func(const char *file, int line, const char *func, const char *expr)
{
printf("assert:%s:%d:%s: %s\n", file, line, func, expr);
mp_raise_msg(&mp_type_AssertionError, MP_ERROR_TEXT("C-level assert"));
}
#endif
#ifdef AOS_COMP_CLI
#if BOARD_HAAS700
#include <console.h>
#endif
/* reg args: fun, cmd, description*/
ALIOS_CLI_CMD_REGISTER(python_entry, python, start micropython)
ALIOS_CLI_CMD_REGISTER(handle_unzip_cmd, unzip, start unzip)
#endif
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/main.c | C | apache-2.0 | 17,021 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "py/builtin.h"
#include "py/mperrno.h"
#include "py/obj.h"
#include "py/runtime.h"
#include "ulog/ulog.h"
#define LOG_TAG "MOD_BATTERY"
STATIC mp_obj_t obj_open(size_t n_args, const mp_obj_t *args)
{
LOGD(LOG_TAG, "entern %s; n_args = %d;\n", __func__, n_args);
int ret = -1;
if (n_args < 1) {
LOGE(LOG_TAG, "%s: args num is illegal :n_args = %d;\n", __func__, n_args);
return mp_const_none;
}
LOGD(LOG_TAG, "%s:out\n", __func__);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR(battery_obj_open, 1, obj_open);
STATIC mp_obj_t obj_close(size_t n_args, const mp_obj_t *args)
{
LOGD(LOG_TAG, "entern %s; n_args = %d;\n", __func__, n_args);
int ret = -1;
if (n_args < 1) {
LOGE(LOG_TAG, "%s: args num is illegal :n_args = %d;\n", __func__, n_args);
return mp_const_none;
}
LOGD(LOG_TAG, "%s:out\n", __func__);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR(battery_obj_close, 1, obj_close);
STATIC mp_obj_t obj_getConnectState(size_t n_args, const mp_obj_t *args)
{
LOGD(LOG_TAG, "entern %s; n_args = %d;\n", __func__, n_args);
int ret = -1;
int state;
if (n_args < 1) {
LOGE(LOG_TAG, "%s: args num is illegal :n_args = %d;\n", __func__, n_args);
return mp_const_none;
}
// if (amp_battery_connect_state_get(&state))
{
LOGE(LOG_TAG, "get battery connect state fail\n");
}
LOGD(LOG_TAG, "%s: state = %d;\n", __func__, state);
return MP_ROM_INT(state);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR(battery_obj_getConnectState, 1, obj_getConnectState);
STATIC mp_obj_t obj_getVoltage(size_t n_args, const mp_obj_t *args)
{
LOGD(LOG_TAG, "entern %s; n_args = %d;\n", __func__, n_args);
int ret = -1;
int voltage;
if (n_args < 1) {
LOGE(LOG_TAG, "%s: args num is illegal :n_args = %d;\n", __func__, n_args);
return mp_const_none;
}
// if (amp_battery_voltage_get(&voltage))
{
LOGE(LOG_TAG, "get battery connect voltage fail\n");
}
LOGD(LOG_TAG, "%s: voltage = %d;\n", __func__, voltage);
return MP_ROM_INT(voltage);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR(battery_obj_getVoltage, 1, obj_getVoltage);
STATIC mp_obj_t obj_getLevel(size_t n_args, const mp_obj_t *args)
{
LOGD(LOG_TAG, "entern %s; n_args = %d;\n", __func__, n_args);
int ret = -1;
int level;
if (n_args < 1) {
LOGE(LOG_TAG, "%s: args num is illegal :n_args = %d;\n", __func__, n_args);
return mp_const_none;
}
// if (amp_battery_level_get(&level))
{
LOGE(LOG_TAG, "get battery connect level fail\n");
}
LOGD(LOG_TAG, "%s: level = %d;\n", __func__, level);
return MP_ROM_INT(level);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR(battery_obj_getLevel, 1, obj_getLevel);
STATIC mp_obj_t obj_getTemperature(size_t n_args, const mp_obj_t *args)
{
LOGD(LOG_TAG, "entern %s; n_args = %d;\n", __func__, n_args);
int ret = -1;
int temperature;
if (n_args < 1) {
LOGE(LOG_TAG, "%s: args num is illegal :n_args = %d;\n", __func__, n_args);
return mp_const_none;
}
// if (amp_battery_temperature_get(&temperature))
{
LOGE(LOG_TAG, "get battery connect temperature fail\n");
}
LOGD(LOG_TAG, "%s: temperature = %d;\n", __func__, temperature);
return MP_ROM_INT(temperature);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR(battery_obj_getTemperature, 1, obj_getTemperature);
STATIC const mp_rom_map_elem_t battery_locals_dict_table[] = {
{ MP_OBJ_NEW_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_Battery) },
{ MP_ROM_QSTR(MP_QSTR_open), MP_ROM_PTR(&battery_obj_open) },
{ MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&battery_obj_close) },
{ MP_ROM_QSTR(MP_QSTR_getConnectState), MP_ROM_PTR(&battery_obj_getConnectState) },
{ MP_ROM_QSTR(MP_QSTR_getVoltage), MP_ROM_PTR(&battery_obj_getVoltage) },
{ MP_ROM_QSTR(MP_QSTR_getLevel), MP_ROM_PTR(&battery_obj_getLevel) },
{ MP_ROM_QSTR(MP_QSTR_getTemperature), MP_ROM_PTR(&battery_obj_getTemperature) },
};
STATIC MP_DEFINE_CONST_DICT(battery_locals_dict, battery_locals_dict_table);
const mp_obj_module_t battery_module = {
.base = { &mp_type_module },
.globals = (mp_obj_dict_t *)&battery_locals_dict,
};
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/modbattery.c | C | apache-2.0 | 4,349 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "py/builtin.h"
#include "py/mperrno.h"
#include "py/obj.h"
#include "py/runtime.h"
#include "ulog/ulog.h"
#define LOG_TAG "MOD_CHARGER"
STATIC mp_obj_t obj_open(size_t n_args, const mp_obj_t *args)
{
LOGD(LOG_TAG, "entern %s; n_args = %d;\n", __func__, n_args);
int ret = -1;
if (n_args < 1) {
LOGE(LOG_TAG, "%s: args num is illegal :n_args = %d;\n", __func__, n_args);
return mp_const_none;
}
LOGD(LOG_TAG, "%s:out\n", __func__);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR(charger_obj_open, 1, obj_open);
STATIC mp_obj_t obj_close(size_t n_args, const mp_obj_t *args)
{
LOGD(LOG_TAG, "entern %s; n_args = %d;\n", __func__, n_args);
int ret = -1;
if (n_args < 1) {
LOGE(LOG_TAG, "%s: args num is illegal :n_args = %d;\n", __func__, n_args);
return mp_const_none;
}
LOGD(LOG_TAG, "%s:out\n", __func__);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR(charger_obj_close, 1, obj_close);
STATIC mp_obj_t obj_getConnectState(size_t n_args, const mp_obj_t *args)
{
LOGD(LOG_TAG, "entern %s; n_args = %d;\n", __func__, n_args);
int ret = -1;
int state;
if (n_args < 1) {
LOGE(LOG_TAG, "%s: args num is illegal :n_args = %d;\n", __func__, n_args);
return mp_const_none;
}
// if (amp_charger_connect_state_get(&state))
{
LOGE(LOG_TAG, "get charger connection state fail\n");
}
LOGD(LOG_TAG, "%s: state = %d;\n", __func__, state);
return MP_ROM_INT(state);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR(charger_obj_getConnectState, 1, obj_getConnectState);
STATIC mp_obj_t obj_getState(size_t n_args, const mp_obj_t *args)
{
LOGD(LOG_TAG, "entern %s; n_args = %d;\n", __func__, n_args);
int ret = -1;
// amp_charger_state_t state = AMP_CHARGER_STAT_SHUTDOWN;
if (n_args < 1) {
LOGE(LOG_TAG, "%s: args num is illegal :n_args = %d;\n", __func__, n_args);
return mp_const_none;
}
// if (amp_charger_state_get(&state))
{
LOGE(LOG_TAG, "get charger connection state fail\n");
}
// LOGD(LOG_TAG, "%s: state = %d;\n", __func__, state);
// ret = state;
return MP_ROM_INT(ret);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR(charger_obj_getState, 1, obj_getState);
STATIC mp_obj_t obj_getCurrent(size_t n_args, const mp_obj_t *args)
{
LOGD(LOG_TAG, "entern %s; n_args = %d;\n", __func__, n_args);
int ret = -1;
int current;
if (n_args < 1) {
LOGE(LOG_TAG, "%s: args num is illegal :n_args = %d;\n", __func__, n_args);
return mp_const_none;
}
// if (amp_charger_current_get(¤t))
{
LOGE(LOG_TAG, "amp_charger_current_get fail\n");
}
LOGD(LOG_TAG, "%s: current = %d;\n", __func__, current);
return MP_ROM_INT(current);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR(charger_obj_getCurrent, 1, obj_getCurrent);
STATIC mp_obj_t obj_switch(size_t n_args, const mp_obj_t *args)
{
LOGD(LOG_TAG, "entern %s; n_args = %d;\n", __func__, n_args);
int ret = 0;
if (n_args < 2) {
LOGE(LOG_TAG, "%s: args num is illegal :n_args = %d;\n", __func__, n_args);
return mp_const_none;
}
int val = (int)mp_obj_get_int(args[1]);
// if (amp_charger_switch_set(val))
{
LOGE(LOG_TAG, "amp_charger_switch_set fail\n");
ret = -1;
}
LOGD(LOG_TAG, "%s: ret = %d;\n", __func__, ret);
return MP_ROM_INT(ret);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR(charger_obj_switch, 2, obj_switch);
STATIC mp_obj_t obj_onConnect(size_t n_args, const mp_obj_t *args)
{
LOGD(LOG_TAG, "entern %s; n_args = %d;\n", __func__, n_args);
int ret = -1;
if (n_args < 1) {
LOGE(LOG_TAG, "%s: args num is illegal :n_args = %d;\n", __func__, n_args);
return mp_const_none;
}
LOGD(LOG_TAG, "%s:out\n", __func__);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR(charger_obj_onConnect, 1, obj_onConnect);
STATIC const mp_rom_map_elem_t charger_locals_dict_table[] = {
{ MP_OBJ_NEW_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_Charger) },
{ MP_ROM_QSTR(MP_QSTR_open), MP_ROM_PTR(&charger_obj_open) },
{ MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&charger_obj_close) },
{ MP_ROM_QSTR(MP_QSTR_getConnectState), MP_ROM_PTR(&charger_obj_getConnectState) },
{ MP_ROM_QSTR(MP_QSTR_getState), MP_ROM_PTR(&charger_obj_getState) },
{ MP_ROM_QSTR(MP_QSTR_getCurrent), MP_ROM_PTR(&charger_obj_getCurrent) },
{ MP_ROM_QSTR(MP_QSTR_switch), MP_ROM_PTR(&charger_obj_switch) },
{ MP_ROM_QSTR(MP_QSTR_onConnect), MP_ROM_PTR(&charger_obj_onConnect) },
};
STATIC MP_DEFINE_CONST_DICT(charger_locals_dict, charger_locals_dict_table);
const mp_obj_module_t charger_module = {
.base = { &mp_type_module },
.globals = (mp_obj_dict_t *)&charger_locals_dict,
};
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/modcharger.c | C | apache-2.0 | 4,893 |
#include <stdio.h>
#include <string.h>
#include "py/builtin.h"
#include "py/mperrno.h"
#include "py/obj.h"
#include "py/runtime.h"
#if 0
extern const mp_obj_type_t pyb_ipc_type;
// this is the actual C-structure for our new object
typedef struct _pyb_ipc_obj_t
{
// base represents some basic information, like type
mp_obj_base_t base;
// a member created by us
kbuf_queue_t* queue;
} pyb_ipc_obj_t;
/*
STATIC const pyb_led_obj_t pyb_led_obj[] = {
{{&pyb_led_type}, PYB_LED_TOP_LEFT_1},
{{&pyb_led_type}, PYB_LED_TOP_RIGHT_1},
{{&pyb_led_type}, PYB_LED_TOP_RIGHT_2},
{{&pyb_led_type}, PYB_LED_TOP_LEFT_2},
};
*/
void ipc_obj_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind)
{
pyb_ipc_obj_t *self = MP_OBJ_TO_PTR(self_in);
mp_printf(print, "queue(%u)", self->queue);
}
STATIC mp_obj_t ipc_obj_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args)
{
kbuf_queue_t *queue;
// check arguments
mp_arg_check_num(n_args, n_kw, 3, 3, false);
char* pname = (char*)mp_obj_str_get_str(args[0]);
//printf("name:%s\r\n",pname);
mp_uint_t size = mp_obj_get_int(args[1]);
mp_uint_t max_msg = mp_obj_get_int(args[2]);
pyb_ipc_obj_t* ipc_obj = m_new_obj(pyb_ipc_obj_t);
if (!ipc_obj) {
mp_raise_OSError(MP_EINVAL);
}
mp_int_t ret = krhino_buf_queue_dyn_create(&queue, pname, size, max_msg);
if(ret){
mp_raise_OSError(EFAULT);
}
ipc_obj->base.type = &pyb_ipc_type;
ipc_obj->queue = queue;
return MP_OBJ_FROM_PTR(ipc_obj);
}
static mp_obj_t ipc_obj_send(mp_obj_t self_in, mp_obj_t msg_in, mp_obj_t size_in)
{
mp_obj_base_t *self = (mp_obj_base_t*)MP_OBJ_TO_PTR(self_in);
pyb_ipc_obj_t* ipc_obj = (pyb_ipc_obj_t *)self;
void *msg = (void *)mp_obj_get_int(msg_in);
mp_uint_t size = mp_obj_get_int(size_in);
mp_int_t ret = krhino_buf_queue_send(ipc_obj->queue, msg, size);
if(ret){
printf("err:%d\r\n",ret);
mp_raise_OSError(EFAULT);
}
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_3(ipc_obj_send_obj, ipc_obj_send);
static mp_obj_t ipc_obj_recv(size_t n_args, const mp_obj_t *args)
{
mp_obj_base_t *self = (mp_obj_base_t*)MP_OBJ_TO_PTR(args[0]);
pyb_ipc_obj_t* ipc_obj = (pyb_ipc_obj_t *)self;
mp_uint_t tick = mp_obj_get_int(args[1]);
void *msg = (void *)mp_obj_get_int(args[2]);
void *psize = mp_obj_get_int(args[3]);
mp_int_t ret = krhino_buf_queue_recv(ipc_obj->queue, tick , msg, psize);
if(ret && ((ret != RHINO_NO_PEND_WAIT) && (ret != RHINO_BLK_TIMEOUT))){
printf("ipc_obj_recv ret:%d\r\n",ret);
mp_raise_OSError(EFAULT);
}
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR(ipc_obj_recv_obj, 4, ipc_obj_recv);
STATIC const mp_rom_map_elem_t ipc_locals_dict_table[] = {
{MP_OBJ_NEW_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_ipc)},
{MP_ROM_QSTR(MP_QSTR_send), MP_ROM_PTR(&ipc_obj_send_obj)},
{MP_ROM_QSTR(MP_QSTR_recv), MP_ROM_PTR(&ipc_obj_recv_obj)},
};
STATIC MP_DEFINE_CONST_DICT(ipc_locals_dict, ipc_locals_dict_table);
const mp_obj_type_t pyb_ipc_type = {
.base = {&mp_type_type},
.name = MP_QSTR_ipc,
.print = ipc_obj_print,
.make_new = ipc_obj_make_new,
.locals_dict = (mp_obj_dict_t *)&ipc_locals_dict,
};
#endif
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/modipc.c | C | apache-2.0 | 3,368 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2013-2015 Damien P. George
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include "modmachine.h"
#include <stdio.h>
#include <string.h>
#include "extmod/machine_i2c.h"
#include "extmod/machine_mem.h"
#include "extmod/machine_pulse.h"
#include "extmod/machine_signal.h"
#include "extmod/machine_spi.h"
#include "extmod/vfs.h"
#include "extmod/vfs_fat.h"
#include "gccollect.h"
#include "shared/runtime/pyexec.h"
#include "py/gc.h"
#include "py/mperrno.h"
#include "py/mphal.h"
#include "py/objstr.h"
#include "py/runtime.h"
#include <aos/kernel.h>
#if MICROPY_PY_MACHINE
#define HAAS_RESET_SOFT (0)
#define HAAS_RESET_POWER_ON (1)
#define HAAS_RESET_HARD (2)
#define HAAS_RESET_WDT (3)
#define HAAS_RESET_DEEPSLEEP (4)
STATIC mp_uint_t reset_cause;
void machine_init(void)
{
}
void machine_deinit(void)
{
// we are doing a soft-reset so change the reset_cause
reset_cause = HAAS_RESET_SOFT;
}
// machine.info([dump_alloc_table])
// Print out lots of information about the board.
STATIC mp_obj_t machine_info(size_t n_args, const mp_obj_t *args)
{
// qstr info
{
size_t n_pool, n_qstr, n_str_data_bytes, n_total_bytes;
qstr_pool_info(&n_pool, &n_qstr, &n_str_data_bytes, &n_total_bytes);
printf(
"qstr:\n n_pool=%u\n n_qstr=%u\n n_str_data_bytes=%u\n "
"n_total_bytes=%u\n",
n_pool, n_qstr, n_str_data_bytes, n_total_bytes);
}
// GC info
{
gc_info_t info;
gc_info(&info);
printf("GC:\n");
printf(" %u total\n", info.total);
printf(" %u : %u\n", info.used, info.free);
printf(" 1=%u 2=%u m=%u\n", info.num_1block, info.num_2block,
info.max_block);
}
// free space on flash
{
#if MICROPY_VFS_FAT
for (mp_vfs_mount_t *vfs = MP_STATE_VM(vfs_mount_table); vfs != NULL;
vfs = vfs->next) {
if (strncmp("/flash", vfs->str, vfs->len) == 0) {
// assumes that it's a FatFs filesystem
fs_user_mount_t *vfs_fat = MP_OBJ_TO_PTR(vfs->obj);
DWORD nclst;
f_getfree(&vfs_fat->fatfs, &nclst);
printf("LFS free: %u bytes\n",
(uint)(nclst * vfs_fat->fatfs.csize * 512));
break;
}
}
#endif
}
if (n_args == 1) {
// arg given means dump gc allocation table
gc_dump_alloc_table();
}
return mp_const_none;
}
MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(machine_info_obj, 0, 1, machine_info);
// Returns a string of 12 bytes (96 bits), which is the unique ID for the MCU.
STATIC mp_obj_t machine_unique_id(void)
{
byte *id = (byte *)(0x1ffff7ac);
return mp_obj_new_bytes(id, 12);
}
MP_DEFINE_CONST_FUN_OBJ_0(machine_unique_id_obj, machine_unique_id);
// Resets the pyboard in a manner similar to pushing the external RESET button.
STATIC mp_obj_t machine_reset(void)
{
aos_reboot();
return mp_const_none;
}
MP_DEFINE_CONST_FUN_OBJ_0(machine_reset_obj, machine_reset);
STATIC mp_obj_t machine_soft_reset(void)
{
pyexec_system_exit = PYEXEC_FORCED_EXIT;
mp_raise_type(&mp_type_SystemExit);
}
MP_DEFINE_CONST_FUN_OBJ_0(machine_soft_reset_obj, machine_soft_reset);
// Activate the bootloader without BOOT* pins.
STATIC NORETURN mp_obj_t machine_bootloader(size_t n_args, const mp_obj_t *args)
{
return mp_const_none;
}
MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(machine_bootloader_obj, 0, 1,
machine_bootloader);
// get or set the MCU frequencies
STATIC mp_obj_t machine_freq(size_t n_args, const mp_obj_t *args)
{
if (n_args == 0) {
// get
mp_obj_t tuple[] = {
mp_obj_new_int(/*HAL_RCC_GetSysClockFreq()*/ 0),
mp_obj_new_int(/*HAL_RCC_GetHCLKFreq()*/ 0),
mp_obj_new_int(/*HAL_RCC_GetPCLK1Freq()*/ 0),
};
return mp_obj_new_tuple(MP_ARRAY_SIZE(tuple), tuple);
} else {
// set
mp_int_t sysclk = mp_obj_get_int(args[0]);
mp_int_t ahb = sysclk;
mp_int_t apb1 = ahb / 4;
mp_int_t apb2 = ahb / 2;
if (n_args > 1) {
ahb = mp_obj_get_int(args[1]);
if (n_args > 2) {
apb1 = mp_obj_get_int(args[2]);
if (n_args > 3) {
apb2 = mp_obj_get_int(args[3]);
}
}
}
int ret = 0;
if (ret == -MP_EINVAL) {
mp_raise_ValueError(MP_ERROR_TEXT("invalid freq"));
} else if (ret < 0) {
void NORETURN __fatal_error(const char *msg);
__fatal_error("can't change freq");
}
return mp_const_none;
}
}
MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(machine_freq_obj, 0, 4, machine_freq);
// idle()
// This executies a wfi machine instruction which reduces power consumption
// of the MCU until an interrupt occurs, at which point execution continues.
STATIC mp_obj_t machine_idle(void)
{
return mp_const_none;
}
MP_DEFINE_CONST_FUN_OBJ_0(machine_idle_obj, machine_idle);
STATIC mp_obj_t machine_lightsleep(size_t n_args, const mp_obj_t *args)
{
if (n_args != 0) {
mp_obj_t args2[2] = { MP_OBJ_NULL, args[0] };
}
return mp_const_none;
}
MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(machine_lightsleep_obj, 0, 1,
machine_lightsleep);
STATIC mp_obj_t machine_deepsleep(size_t n_args, const mp_obj_t *args)
{
if (n_args != 0) {
mp_obj_t args2[2] = { MP_OBJ_NULL, args[0] };
}
return mp_const_none;
}
MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(machine_deepsleep_obj, 0, 1,
machine_deepsleep);
STATIC mp_obj_t machine_reset_cause(void)
{
return MP_OBJ_NEW_SMALL_INT(reset_cause);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_0(machine_reset_cause_obj, machine_reset_cause);
// Return a 30-bit hardware generated random number.
STATIC mp_obj_t machine_rng(void)
{
return mp_obj_new_int(aos_rand());
}
MP_DEFINE_CONST_FUN_OBJ_0(machine_rng_obj, machine_rng);
STATIC mp_obj_t machine_disable_irq(void)
{
mp_uint_t state = MICROPY_BEGIN_ATOMIC_SECTION();
return mp_obj_new_int(state);
}
MP_DEFINE_CONST_FUN_OBJ_0(machine_disable_irq_obj, machine_disable_irq);
STATIC mp_obj_t machine_enable_irq(mp_obj_t state_in)
{
mp_uint_t state = mp_obj_get_int(state_in);
MICROPY_END_ATOMIC_SECTION(state);
return mp_const_none;
}
MP_DEFINE_CONST_FUN_OBJ_1(machine_enable_irq_obj, machine_enable_irq);
STATIC mp_obj_t machine_wake_reason(size_t n_args, const mp_obj_t *pos_args,
mp_map_t *kw_args)
{
return MP_OBJ_NEW_SMALL_INT(0);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_KW(machine_wake_reason_obj, 0,
machine_wake_reason);
STATIC const mp_rom_map_elem_t machine_module_globals_table[] = {
{ MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_machine) },
{ MP_ROM_QSTR(MP_QSTR_info), MP_ROM_PTR(&machine_info_obj) },
{ MP_ROM_QSTR(MP_QSTR_unique_id), MP_ROM_PTR(&machine_unique_id_obj) },
{ MP_ROM_QSTR(MP_QSTR_freq), MP_ROM_PTR(&machine_freq_obj) },
{ MP_ROM_QSTR(MP_QSTR_reset), MP_ROM_PTR(&machine_reset_obj) },
{ MP_ROM_QSTR(MP_QSTR_soft_reset), MP_ROM_PTR(&machine_soft_reset_obj) },
{ MP_ROM_QSTR(MP_QSTR_bootloader), MP_ROM_PTR(&machine_bootloader_obj) },
{ MP_ROM_QSTR(MP_QSTR_rng), MP_ROM_PTR(&machine_rng_obj) },
{ MP_ROM_QSTR(MP_QSTR_mem8), MP_ROM_PTR(&machine_mem8_obj) },
{ MP_ROM_QSTR(MP_QSTR_mem16), MP_ROM_PTR(&machine_mem16_obj) },
{ MP_ROM_QSTR(MP_QSTR_mem32), MP_ROM_PTR(&machine_mem32_obj) },
{ MP_ROM_QSTR(MP_QSTR_idle), MP_ROM_PTR(&machine_idle_obj) },
{ MP_ROM_QSTR(MP_QSTR_sleep), MP_ROM_PTR(&machine_lightsleep_obj) },
{ MP_ROM_QSTR(MP_QSTR_lightsleep), MP_ROM_PTR(&machine_lightsleep_obj) },
{ MP_ROM_QSTR(MP_QSTR_deepsleep), MP_ROM_PTR(&machine_deepsleep_obj) },
{ MP_ROM_QSTR(MP_QSTR_time_pulse_us),
MP_ROM_PTR(&machine_time_pulse_us_obj) },
{ MP_ROM_QSTR(MP_QSTR_disable_irq), MP_ROM_PTR(&machine_disable_irq_obj) },
{ MP_ROM_QSTR(MP_QSTR_enable_irq), MP_ROM_PTR(&machine_enable_irq_obj) },
// wake abilities
{ MP_ROM_QSTR(MP_QSTR_SLEEP), MP_ROM_INT(MACHINE_WAKE_SLEEP) },
{ MP_ROM_QSTR(MP_QSTR_DEEPSLEEP), MP_ROM_INT(MACHINE_WAKE_DEEPSLEEP) },
{ MP_ROM_QSTR(MP_QSTR_Pin), MP_ROM_PTR(&machine_pin_type) },
{ MP_ROM_QSTR(MP_QSTR_Signal), MP_ROM_PTR(&machine_signal_type) },
{ MP_ROM_QSTR(MP_QSTR_ADC), MP_ROM_PTR(&machine_adc_type) },
#if MICROPY_PY_MACHINE_DAC
{ MP_ROM_QSTR(MP_QSTR_DAC), MP_ROM_PTR(&machine_dac_type) },
#endif
{ MP_ROM_QSTR(MP_QSTR_I2C), MP_ROM_PTR(&machine_hw_i2c_type) },
{ MP_ROM_QSTR(MP_QSTR_SoftI2C), MP_ROM_PTR(&mp_machine_soft_i2c_type) },
{ MP_ROM_QSTR(MP_QSTR_PWM), MP_ROM_PTR(&machine_pwm_type) },
{ MP_ROM_QSTR(MP_QSTR_RTC), MP_ROM_PTR(&machine_rtc_type) },
{ MP_ROM_QSTR(MP_QSTR_SPI), MP_ROM_PTR(&machine_hw_spi_type) },
{ MP_ROM_QSTR(MP_QSTR_SoftSPI), MP_ROM_PTR(&mp_machine_soft_spi_type) },
{ MP_ROM_QSTR(MP_QSTR_UART), MP_ROM_PTR(&machine_uart_type) },
{ MP_ROM_QSTR(MP_QSTR_Timer), MP_ROM_PTR(&machine_timer_type) },
{ MP_ROM_QSTR(MP_QSTR_SoftTimer), MP_ROM_PTR(&mp_machine_soft_timer_type) },
{ MP_ROM_QSTR(MP_QSTR_WDT), MP_ROM_PTR(&machine_wdt_type) },
// { MP_ROM_QSTR(MP_QSTR_SDCard), MP_ROM_PTR(&machine_sdcard_type) },
// Reset reasons
{ MP_ROM_QSTR(MP_QSTR_reset_cause), MP_ROM_PTR(&machine_reset_cause_obj) },
{ MP_ROM_QSTR(MP_QSTR_HARD_RESET), MP_ROM_INT(MP_HARD_RESET) },
{ MP_ROM_QSTR(MP_QSTR_PWRON_RESET), MP_ROM_INT(MP_PWRON_RESET) },
{ MP_ROM_QSTR(MP_QSTR_WDT_RESET), MP_ROM_INT(MP_WDT_RESET) },
{ MP_ROM_QSTR(MP_QSTR_DEEPSLEEP_RESET), MP_ROM_INT(MP_DEEPSLEEP_RESET) },
{ MP_ROM_QSTR(MP_QSTR_SOFT_RESET), MP_ROM_INT(MP_SOFT_RESET) },
// Wake reasons
{ MP_ROM_QSTR(MP_QSTR_wake_reason), MP_ROM_PTR(&machine_wake_reason_obj) },
{ MP_ROM_QSTR(MP_QSTR_PIN_WAKE), MP_ROM_INT(SLEEP_WAKEUP_EXT0) },
{ MP_ROM_QSTR(MP_QSTR_EXT0_WAKE), MP_ROM_INT(SLEEP_WAKEUP_EXT0) },
{ MP_ROM_QSTR(MP_QSTR_EXT1_WAKE), MP_ROM_INT(SLEEP_WAKEUP_EXT1) },
{ MP_ROM_QSTR(MP_QSTR_TIMER_WAKE), MP_ROM_INT(SLEEP_WAKEUP_TIMER) },
{ MP_ROM_QSTR(MP_QSTR_TOUCHPAD_WAKE), MP_ROM_INT(SLEEP_WAKEUP_TOUCHPAD) },
{ MP_ROM_QSTR(MP_QSTR_ULP_WAKE), MP_ROM_INT(SLEEP_WAKEUP_ULP) },
// class constants
{ MP_ROM_QSTR(MP_QSTR_IDLE), MP_ROM_INT(PWR_MODE_ACTIVE) },
{ MP_ROM_QSTR(MP_QSTR_SLEEP), MP_ROM_INT(PWR_MODE_LPDS) },
{ MP_ROM_QSTR(MP_QSTR_DEEPSLEEP), MP_ROM_INT(PWR_MODE_HIBERNATE) },
{ MP_ROM_QSTR(MP_QSTR_POWER_ON),
MP_ROM_INT(SLP_PWRON_RESET) }, // legacy constant
{ MP_ROM_QSTR(MP_QSTR_PWRON_RESET), MP_ROM_INT(SLP_PWRON_RESET) },
{ MP_ROM_QSTR(MP_QSTR_HARD_RESET), MP_ROM_INT(SLP_HARD_RESET) },
{ MP_ROM_QSTR(MP_QSTR_WDT_RESET), MP_ROM_INT(SLP_WDT_RESET) },
{ MP_ROM_QSTR(MP_QSTR_DEEPSLEEP_RESET), MP_ROM_INT(SLP_HIB_RESET) },
{ MP_ROM_QSTR(MP_QSTR_SOFT_RESET), MP_ROM_INT(SLP_SOFT_RESET) },
{ MP_ROM_QSTR(MP_QSTR_WLAN_WAKE), MP_ROM_INT(SLP_WAKED_BY_WLAN) },
{ MP_ROM_QSTR(MP_QSTR_PIN_WAKE), MP_ROM_INT(SLP_WAKED_BY_GPIO) },
{ MP_ROM_QSTR(MP_QSTR_RTC_WAKE), MP_ROM_INT(SLP_WAKED_BY_RTC) },
};
STATIC MP_DEFINE_CONST_DICT(machine_module_globals,
machine_module_globals_table);
const mp_obj_module_t mp_module_machine = {
.base = { &mp_type_module },
.globals = (mp_obj_dict_t *)&machine_module_globals,
};
MP_REGISTER_MODULE(MP_QSTR_machine, mp_module_machine, MICROPY_PY_MACHINE);
#endif
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/modmachine.c | C | apache-2.0 | 12,768 |
#ifndef MICROPY_INCLUDED_HAAS_MODMACHINE_H
#define MICROPY_INCLUDED_HAAS_MODMACHINE_H
#include "py/obj.h"
typedef enum {
// MACHINE_WAKE_IDLE=0x01,
MACHINE_WAKE_SLEEP = 0x02,
MACHINE_WAKE_DEEPSLEEP = 0x04,
SLEEP_WAKEUP_EXT0,
SLEEP_WAKEUP_EXT1,
SLEEP_WAKEUP_TIMER,
SLEEP_WAKEUP_TOUCHPAD,
SLEEP_WAKEUP_ULP,
PWR_MODE_ACTIVE,
PWR_MODE_LPDS,
PWR_MODE_HIBERNATE,
SLP_PWRON_RESET,
SLP_HARD_RESET,
SLP_WDT_RESET,
SLP_HIB_RESET,
SLP_SOFT_RESET,
SLP_WAKED_BY_WLAN,
SLP_WAKED_BY_GPIO,
SLP_WAKED_BY_RTC,
MP_HARD_RESET,
MP_PWRON_RESET,
MP_WDT_RESET,
MP_DEEPSLEEP_RESET,
MP_SOFT_RESET
} wake_type_t;
extern const mp_obj_type_t machine_pin_type;
extern const mp_obj_type_t mp_machine_soft_i2c_type;
extern const mp_obj_type_t mp_machine_soft_spi_type;
extern const mp_obj_type_t mp_machine_soft_timer_type;
extern const mp_obj_type_t machine_sdcard_type;
extern const mp_obj_type_t machine_hw_i2c_type;
extern const mp_obj_type_t machine_hw_spi_type;
extern const mp_obj_type_t machine_adc_type;
extern const mp_obj_type_t machine_pwm_type;
extern const mp_obj_type_t machine_uart_type;
extern const mp_obj_type_t machine_rtc_type;
extern const mp_obj_type_t machine_timer_type;
extern const mp_obj_type_t machine_can_type;
#if MICROPY_PY_MACHINE_DAC
extern const mp_obj_type_t machine_dac_type;
#endif
extern const mp_obj_type_t machine_wdt_type;
void machine_init(void);
void machine_deinit(void);
void machine_pins_init(void);
void machine_pins_deinit(void);
void machine_timer_deinit_all(void);
#endif // MICROPY_INCLUDED_HAAS_MODMACHINE_H
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/modmachine.h | C | apache-2.0 | 1,634 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aos_network.h"
#include "py/builtin.h"
#include "py/mperrno.h"
#include "py/obj.h"
#include "py/runtime.h"
#include "py/stackctrl.h"
#include "aos_log.h"
#include "utility.h"
#include "aos/kernel.h"
#include "ulog/ulog.h"
#define LOG_TAG "mod_network"
typedef struct _aos_wifi_obj_t {
mp_obj_base_t base;
int if_mode;
} aos_wifi_if_obj_t;
const mp_obj_type_t aos_wifi_if_type;
STATIC const aos_wifi_if_obj_t aos_wifi_sta_obj = {{&aos_wifi_if_type}, AOS_NETWORK_WIFI_STA};
STATIC const aos_wifi_if_obj_t aos_wifi_ap_obj = {{&aos_wifi_if_type}, AOS_NETWORK_WIFI_AP};
STATIC aos_wifi_manager_t *wifi_manager = NULL;
static mp_obj_t on_wifi_event_cb = mp_const_none;
static void wifi_event_cb(uint32_t event_id, void *context)
{
if (on_wifi_event_cb != mp_const_none && mp_obj_is_callable(on_wifi_event_cb)) {
callback_to_python_LoBo(on_wifi_event_cb, MP_OBJ_NEW_SMALL_INT(event_id), NULL);
}
}
STATIC mp_obj_t wifi_init()
{
return mp_const_none;
}
MP_DEFINE_CONST_FUN_OBJ_0(aos_wifi_init_obj, wifi_init);
STATIC mp_obj_t wifi_active(mp_obj_t self_in, mp_obj_t active)
{
if (wifi_manager->is_started) {
return mp_const_none;
}
if (mp_obj_is_true(active)) {
aos_wifi_start(wifi_manager);
} else {
aos_wifi_stop(wifi_manager);
}
return mp_const_none;
}
MP_DEFINE_CONST_FUN_OBJ_2(aos_wifi_active_obj, wifi_active);
STATIC mp_obj_t wifi_connect(mp_obj_t self_in, mp_obj_t ssid_in, mp_obj_t pwd_in)
{
const char *_ssid = mp_obj_str_get_str(ssid_in);
const char *_pwd = mp_obj_str_get_str(pwd_in);
if (!wifi_manager->wifi_state == AOS_NET_STA_CONNECTED) {
return mp_const_none;
}
if (!wifi_manager) {
wifi_init();
}
pthread_mutex_lock(&wifi_manager->network_mutex);
if (!wifi_manager->wifi_state == AOS_NET_STA_CONNECTED) {
pthread_mutex_unlock(&wifi_manager->network_mutex);
return mp_const_none;
}
MP_THREAD_GIL_EXIT();
aos_wifi_connect(_ssid, _pwd);
pthread_mutex_unlock(&wifi_manager->network_mutex);
MP_THREAD_GIL_ENTER();
return mp_const_none;
}
MP_DEFINE_CONST_FUN_OBJ_3(aos_wifi_connect_obj, wifi_connect);
STATIC mp_obj_t wifi_disconnect(mp_obj_t self_in)
{
if (wifi_manager != NULL) {
pthread_mutex_lock(&wifi_manager->network_mutex);
aos_wifi_disconnect();
pthread_mutex_unlock(&wifi_manager->network_mutex);
}
return mp_const_none;
}
MP_DEFINE_CONST_FUN_OBJ_1(aos_wifi_disconnect_obj, wifi_disconnect);
STATIC mp_obj_t wifi_get_status(size_t n_args, const mp_obj_t *args)
{
if (wifi_manager != NULL)
return mp_obj_new_int(wifi_manager->wifi_state);
else {
return mp_obj_new_int(-1);
}
}
MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(aos_wifi_get_status_obj, 1, 2, wifi_get_status);
STATIC mp_obj_t wifi_is_connected(mp_obj_t self_in)
{
if (wifi_manager->wifi_state == AOS_NET_STA_GOT_IP || wifi_manager->wifi_state == AOS_NET_STA_CONNECTED)
return mp_obj_new_bool(true);
return mp_obj_new_bool(false);
}
MP_DEFINE_CONST_FUN_OBJ_1(wifi_is_connected_obj, wifi_is_connected);
STATIC mp_obj_t wifi_on(mp_obj_t self_in, mp_obj_t func)
{
on_wifi_event_cb = func;
return mp_const_none;
}
MP_DEFINE_CONST_FUN_OBJ_2(aos_wifi_on_obj, wifi_on);
STATIC mp_obj_t wifi_get_info(mp_obj_t self_in)
{
aos_wifi_info_t wifi_info = { 0 };
mp_int_t ret = aos_wifi_get_info(&wifi_info);
if (ret < 0) {
AOS_LOGE(LOG_TAG, "Failed to get wifi info\r\n");
return mp_const_none;
}
mp_obj_t dict = mp_obj_new_dict(4);
mp_obj_dict_store(dict, MP_OBJ_NEW_QSTR(qstr_from_str("ssid")), mp_obj_new_strn(wifi_info.ssid));
mp_obj_dict_store(dict, MP_OBJ_NEW_QSTR(qstr_from_str("mac")), mp_obj_new_strn(wifi_info.mac));
mp_obj_dict_store(dict, MP_OBJ_NEW_QSTR(qstr_from_str("ip")), mp_obj_new_strn(wifi_info.ip));
mp_obj_dict_store(dict, MP_OBJ_NEW_QSTR(qstr_from_str("rssi")), mp_obj_new_int(wifi_info.rssi));
return dict;
}
MP_DEFINE_CONST_FUN_OBJ_1(aos_wifi_get_info_obj, wifi_get_info);
static int netutils_format_ipv4_addr(uint8_t *in_ip, char* out_ip)
{
mp_uint_t ip_len;
if (sizeof(in_ip) < 4) {
AOS_LOGE("network", "invalid ip format\r\n");
return -1;
}
ip_len = snprintf(out_ip, 16, "%u.%u.%u.%u", in_ip[3], in_ip[2], in_ip[1], in_ip[0]);
return ip_len;
}
#ifndef NETUTILS_IPV4ADDR_BUFSIZE
#define NETUTILS_IPV4ADDR_BUFSIZE 4
#endif
static void netutils_parse_ipv4_addr(mp_obj_t addr_in, uint8_t *out_ip)
{
size_t addr_len;
const char *addr_str = mp_obj_str_get_data(addr_in, &addr_len);
if (addr_len == 0) {
// special case of no address given
memset(out_ip, 0, NETUTILS_IPV4ADDR_BUFSIZE);
return;
}
const char *s = addr_str;
const char *s_top = addr_str + addr_len;
for (mp_uint_t i = 3; ; i--) {
mp_uint_t val = 0;
for (; s < s_top && *s != '.'; s++) {
val = val * 10 + *s - '0';
}
// out_ip[i] = val;
out_ip[NETUTILS_IPV4ADDR_BUFSIZE - 1 - i] = val;
if (i == 0 && s == s_top) {
return;
} else if (i > 0 && s < s_top && *s == '.') {
s++;
} else {
mp_raise_ValueError(MP_ERROR_TEXT("invalid arguments"));
}
}
}
STATIC mp_obj_t aos_ifconfig(size_t n_args, const mp_obj_t *args)
{
aos_ifconfig_info_t info = { 0 };
if (n_args == 1) {
// get
mp_int_t ret = aos_net_get_ifconfig(&info);
if (ret != 0) {
AOS_LOGI(LOG_TAG, "netmgr_get_config failed, ret = %d\n", ret);
return mp_const_none;
}
mp_obj_t tuple[4] = {
mp_obj_new_strn(info.ip_addr),
mp_obj_new_strn(info.mask),
mp_obj_new_strn(info.gw),
mp_obj_new_strn(info.dns_server),
mp_obj_new_strn(info.mac),
};
return mp_obj_new_tuple(5, tuple);
} else {
// set
if (mp_obj_is_type(args[1], &mp_type_tuple) || mp_obj_is_type(args[1], &mp_type_list)) {
mp_obj_t *items;
mp_obj_get_array_fixed_n(args[1], 4, &items);
netutils_format_ipv4_addr(items[0], (void *)&info.ip_addr);
netutils_format_ipv4_addr(items[1], (void *)&info.mask);
netutils_format_ipv4_addr(items[2], (void *)&info.gw);
netutils_format_ipv4_addr(items[3], (void *)&info.dns_server);
}
mp_int_t ret = aos_net_set_ifconfig(&info);
return mp_obj_new_int(ret);
}
return mp_const_none;
}
MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(aos_ifconfig_obj, 1, 2, aos_ifconfig);
STATIC mp_obj_t haas_wlan_scan(mp_obj_t self_in)
{
mp_obj_t list = mp_obj_new_list(0, NULL);
aos_wifi_ap_list_t wifi_ap_records[16] = { 0 };
memset(wifi_ap_records, 0, sizeof(aos_wifi_ap_list_t) * 16);
MP_THREAD_GIL_EXIT();
int ap_num = aos_wifi_scan(wifi_ap_records, 16);
MP_THREAD_GIL_ENTER();
int index = 0;
while (index < 16 && index < ap_num) {
if (strlen(wifi_ap_records[index].ssid) > 0) {
mp_obj_tuple_t *t = mp_obj_new_tuple(6, NULL);
char *x = memchr(wifi_ap_records[index].ssid, 0, sizeof(wifi_ap_records[index].ssid));
int ssid_len = x ? x - wifi_ap_records[index].ssid : sizeof(wifi_ap_records[index].ssid);
t->items[0] = mp_obj_new_bytes(wifi_ap_records[index].ssid, ssid_len);
t->items[1] = mp_obj_new_bytes(wifi_ap_records[index].bssid, sizeof(wifi_ap_records[index].bssid));
t->items[2] = MP_OBJ_NEW_SMALL_INT(wifi_ap_records[index].channel);
t->items[3] = MP_OBJ_NEW_SMALL_INT((signed char)wifi_ap_records[index].ap_power);
t->items[4] = MP_OBJ_NEW_SMALL_INT(wifi_ap_records[index].sec_type);
t->items[5] = mp_const_false; // XXX hidden?
mp_obj_list_append(list, MP_OBJ_FROM_PTR(t));
}
index++;
}
return list;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(aos_wifi_scan_obj, haas_wlan_scan);
STATIC const mp_rom_map_elem_t wifi_if_locals_dict_table[] = {
{ MP_ROM_QSTR(MP_QSTR_active), MP_ROM_PTR(&aos_wifi_active_obj) },
{ MP_OBJ_NEW_QSTR(MP_QSTR_connect), MP_ROM_PTR(&aos_wifi_connect_obj) },
{ MP_OBJ_NEW_QSTR(MP_QSTR_disconnect), MP_ROM_PTR(&aos_wifi_disconnect_obj) },
{ MP_OBJ_NEW_QSTR(MP_QSTR_status), MP_ROM_PTR(&aos_wifi_get_status_obj) },
{ MP_ROM_QSTR(MP_QSTR_scan), MP_ROM_PTR(&aos_wifi_scan_obj) },
{ MP_ROM_QSTR(MP_QSTR_isconnected), MP_ROM_PTR(&wifi_is_connected_obj) },
// { MP_ROM_QSTR(MP_QSTR_config), MP_ROM_PTR(&esp_config_obj) },
{ MP_OBJ_NEW_QSTR(MP_QSTR_ifconfig), MP_ROM_PTR(&aos_ifconfig_obj) },
{ MP_OBJ_NEW_QSTR(MP_QSTR_on), MP_ROM_PTR(&aos_wifi_on_obj) },
};
STATIC MP_DEFINE_CONST_DICT(wifi_if_locals_dict, wifi_if_locals_dict_table);
const mp_obj_type_t aos_wifi_if_type = {
{ &mp_type_type },
.name = MP_QSTR_WIFI,
.locals_dict = (mp_obj_t)&wifi_if_locals_dict,
};
STATIC mp_obj_t get_wifi(size_t n_args, const mp_obj_t *args)
{
int idx = (n_args > 0) ? mp_obj_get_int(args[0]) : AOS_NETWORK_WIFI_STA;
if (idx == AOS_NETWORK_WIFI_STA) {
if (!wifi_manager) {
wifi_manager = calloc(sizeof(aos_wifi_manager_t), 1);
if (!wifi_manager) {
return MP_ROM_INT(-MP_ENOMEM);
}
wifi_manager->cb = wifi_event_cb;
wifi_manager->wifi_state = AOS_NET_NOINIT;
wifi_manager->wifi_mode = AOS_NETWORK_WIFI_STA;
wifi_manager->is_initialized = false;
wifi_manager->is_started = false;
pthread_mutex_init(&wifi_manager->network_mutex, NULL);
}
pthread_mutex_lock(&wifi_manager->network_mutex);
aos_wifi_init(wifi_manager);
pthread_mutex_unlock(&wifi_manager->network_mutex);
return MP_OBJ_FROM_PTR(&aos_wifi_sta_obj);
} else if (idx == AOS_NETWORK_WIFI_AP) {
return MP_OBJ_FROM_PTR(&aos_wifi_ap_obj);
} else {
mp_raise_ValueError(MP_ERROR_TEXT("invalid WLAN interface identifier"));
}
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(aos_get_wifi_obj, 0, 1, get_wifi);
STATIC const mp_rom_map_elem_t mp_module_network_globals_table[] = {
{ MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_network) },
// { MP_ROM_QSTR(MP_QSTR___init__), MP_ROM_PTR(&aos_wifi_init_obj) },
{ MP_ROM_QSTR(MP_QSTR_WLAN), MP_ROM_PTR(&aos_get_wifi_obj) },
{ MP_ROM_QSTR(MP_QSTR_STA_IF), MP_ROM_INT(AOS_NETWORK_WIFI_STA)},
{ MP_ROM_QSTR(MP_QSTR_AP_IF), MP_ROM_INT(AOS_NETWORK_WIFI_AP)},
{ MP_ROM_QSTR(MP_QSTR_STA_STARTED), MP_ROM_INT(AOS_NET_STA_STARTED) },
{ MP_ROM_QSTR(MP_QSTR_STA_CONNECTED), MP_ROM_INT(AOS_NET_STA_CONNECTED) },
{ MP_ROM_QSTR(MP_QSTR_STA_GOT_IP), MP_ROM_INT(AOS_NET_STA_GOT_IP) },
{ MP_ROM_QSTR(MP_QSTR_STA_LOST_IP), MP_ROM_INT(AOS_NET_STA_LOST_IP) },
{ MP_ROM_QSTR(MP_QSTR_STA_DISCONNECTED), MP_ROM_INT(AOS_NET_STA_DISCONNECTED) },
{ MP_ROM_QSTR(MP_QSTR_STA_STOPED), MP_ROM_INT(AOS_NET_STA_STOPED) },
{ MP_ROM_QSTR(MP_QSTR_STA_UNKNOWN), MP_ROM_INT(AOS_NET_STATE_UNKNOWN) },
{ MP_ROM_QSTR(MP_QSTR_AUTH_OPEN), MP_ROM_INT(AOS_WIFI_AUTH_OPEN) },
{ MP_ROM_QSTR(MP_QSTR_AUTH_WEP), MP_ROM_INT(AOS_WIFI_AUTH_WEP) },
{ MP_ROM_QSTR(MP_QSTR_AUTH_WPA_PSK), MP_ROM_INT(AOS_WIFI_AUTH_WPA_PSK) },
{ MP_ROM_QSTR(MP_QSTR_AUTH_WPA2_PSK), MP_ROM_INT(AOS_WIFI_AUTH_WPA2_PSK) },
{ MP_ROM_QSTR(MP_QSTR_AUTH_WPA_WPA2_PSK), MP_ROM_INT(AOS_WIFI_AUTH_WPA_WPA2_PSK) },
{ MP_ROM_QSTR(MP_QSTR_AUTH_WPA2_ENTERPRISE), MP_ROM_INT(AOS_WIFI_AUTH_WPA2_ENTERPRISE) },
};
STATIC MP_DEFINE_CONST_DICT(mp_module_network_globals, mp_module_network_globals_table);
const mp_obj_module_t mp_module_network = {
.base = { &mp_type_module },
.globals = (mp_obj_dict_t *)&mp_module_network_globals,
};
MP_REGISTER_MODULE(MP_QSTR_network, mp_module_network, 1);
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/modnetwork.c | C | apache-2.0 | 11,939 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "py/builtin.h"
#include "py/mperrno.h"
#include "py/obj.h"
#include "py/runtime.h"
#include "ulog/ulog.h"
#define LOG_TAG "MOD_PM"
STATIC mp_obj_t obj_open(size_t n_args, const mp_obj_t *args)
{
LOGD(LOG_TAG, "entern %s; n_args = %d;\n", __func__, n_args);
int ret = -1;
void *instance = NULL;
if (n_args < 5) {
LOGE(LOG_TAG, "%s: args num is illegal :n_args = %d;\n", __func__, n_args);
return mp_const_none;
}
LOGD(LOG_TAG, "%s:out\n", __func__);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR(pm_obj_open, 5, obj_open);
STATIC mp_obj_t obj_close(size_t n_args, const mp_obj_t *args)
{
LOGD(LOG_TAG, "entern %s; n_args = %d;\n", __func__, n_args);
int ret = -1;
void *instance = NULL;
if (n_args < 5) {
LOGE(LOG_TAG, "%s: args num is illegal :n_args = %d;\n", __func__, n_args);
return mp_const_none;
}
LOGD(LOG_TAG, "%s:out\n", __func__);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR(pm_obj_close, 5, obj_close);
STATIC mp_obj_t obj_setAutosleepMode(size_t n_args, const mp_obj_t *args)
{
LOGD(LOG_TAG, "entern %s; n_args = %d;\n", __func__, n_args);
int ret = -1;
void *instance = NULL;
if (n_args < 5) {
LOGE(LOG_TAG, "%s: args num is illegal :n_args = %d;\n", __func__, n_args);
return mp_const_none;
}
LOGD(LOG_TAG, "%s:out\n", __func__);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR(pm_obj_setAutosleepMode, 5, obj_setAutosleepMode);
STATIC mp_obj_t obj_getAutosleepMode(size_t n_args, const mp_obj_t *args)
{
LOGD(LOG_TAG, "entern %s; n_args = %d;\n", __func__, n_args);
int ret = -1;
void *instance = NULL;
if (n_args < 5) {
LOGE(LOG_TAG, "%s: args num is illegal :n_args = %d;\n", __func__, n_args);
return mp_const_none;
}
LOGD(LOG_TAG, "%s:out\n", __func__);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR(pm_obj_getAutosleepMode, 5, obj_getAutosleepMode);
STATIC mp_obj_t obj_sleep(size_t n_args, const mp_obj_t *args)
{
LOGD(LOG_TAG, "entern %s; n_args = %d;\n", __func__, n_args);
int ret = -1;
void *instance = NULL;
if (n_args < 5) {
LOGE(LOG_TAG, "%s: args num is illegal :n_args = %d;\n", __func__, n_args);
return mp_const_none;
}
LOGD(LOG_TAG, "%s:out\n", __func__);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR(pm_obj_sleep, 5, obj_sleep);
STATIC mp_obj_t obj_powerDown(size_t n_args, const mp_obj_t *args)
{
LOGD(LOG_TAG, "entern %s; n_args = %d;\n", __func__, n_args);
int ret = -1;
void *instance = NULL;
if (n_args < 5) {
LOGE(LOG_TAG, "%s: args num is illegal :n_args = %d;\n", __func__, n_args);
return mp_const_none;
}
LOGD(LOG_TAG, "%s:out\n", __func__);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR(pm_obj_powerDown, 5, obj_powerDown);
STATIC mp_obj_t obj_powerReset(size_t n_args, const mp_obj_t *args)
{
LOGD(LOG_TAG, "entern %s; n_args = %d;\n", __func__, n_args);
int ret = -1;
void *instance = NULL;
if (n_args < 5) {
LOGE(LOG_TAG, "%s: args num is illegal :n_args = %d;\n", __func__, n_args);
return mp_const_none;
}
LOGD(LOG_TAG, "%s:out\n", __func__);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR(pm_obj_powerReset, 5, obj_powerReset);
STATIC mp_obj_t obj_wakelockLock(size_t n_args, const mp_obj_t *args)
{
LOGD(LOG_TAG, "entern %s; n_args = %d;\n", __func__, n_args);
int ret = -1;
void *instance = NULL;
if (n_args < 5) {
LOGE(LOG_TAG, "%s: args num is illegal :n_args = %d;\n", __func__, n_args);
return mp_const_none;
}
LOGD(LOG_TAG, "%s:out\n", __func__);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR(pm_obj_wakelockLock, 5, obj_wakelockLock);
STATIC mp_obj_t obj_wakelockUnlock(size_t n_args, const mp_obj_t *args)
{
LOGD(LOG_TAG, "entern %s; n_args = %d;\n", __func__, n_args);
int ret = -1;
void *instance = NULL;
if (n_args < 5) {
LOGE(LOG_TAG, "%s: args num is illegal :n_args = %d;\n", __func__, n_args);
return mp_const_none;
}
LOGD(LOG_TAG, "%s:out\n", __func__);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR(pm_obj_wakelockUnlock, 5, obj_wakelockUnlock);
STATIC mp_obj_t obj_wakelockTimedlock(size_t n_args, const mp_obj_t *args)
{
LOGD(LOG_TAG, "entern %s; n_args = %d;\n", __func__, n_args);
int ret = -1;
void *instance = NULL;
if (n_args < 5) {
LOGE(LOG_TAG, "%s: args num is illegal :n_args = %d;\n", __func__, n_args);
return mp_const_none;
}
LOGD(LOG_TAG, "%s:out\n", __func__);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR(pm_obj_wakelockTimedlock, 5, obj_wakelockTimedlock);
STATIC mp_obj_t obj_onPwrkey(size_t n_args, const mp_obj_t *args)
{
LOGD(LOG_TAG, "entern %s; n_args = %d;\n", __func__, n_args);
int ret = -1;
void *instance = NULL;
if (n_args < 5) {
LOGE(LOG_TAG, "%s: args num is illegal :n_args = %d;\n", __func__, n_args);
return mp_const_none;
}
LOGD(LOG_TAG, "%s:out\n", __func__);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR(pm_obj_onPwrkey, 5, obj_onPwrkey);
STATIC const mp_rom_map_elem_t pm_locals_dict_table[] = {
{ MP_OBJ_NEW_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_PM) },
{ MP_ROM_QSTR(MP_QSTR_open), MP_ROM_PTR(&pm_obj_open) },
{ MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&pm_obj_close) },
{ MP_ROM_QSTR(MP_QSTR_setAutosleepMode), MP_ROM_PTR(&pm_obj_setAutosleepMode) },
{ MP_ROM_QSTR(MP_QSTR_getAutosleepMode), MP_ROM_PTR(&pm_obj_getAutosleepMode) },
{ MP_ROM_QSTR(MP_QSTR_sleep), MP_ROM_PTR(&pm_obj_sleep) },
{ MP_ROM_QSTR(MP_QSTR_powerDown), MP_ROM_PTR(&pm_obj_powerDown) },
{ MP_ROM_QSTR(MP_QSTR_powerReset), MP_ROM_PTR(&pm_obj_powerReset) },
{ MP_ROM_QSTR(MP_QSTR_wakelockLock), MP_ROM_PTR(&pm_obj_wakelockLock) },
{ MP_ROM_QSTR(MP_QSTR_wakelockUnlock), MP_ROM_PTR(&pm_obj_wakelockUnlock) },
{ MP_ROM_QSTR(MP_QSTR_wakelockTimedlock), MP_ROM_PTR(&pm_obj_wakelockTimedlock) },
{ MP_ROM_QSTR(MP_QSTR_onPwrkey), MP_ROM_PTR(&pm_obj_onPwrkey) },
};
STATIC MP_DEFINE_CONST_DICT(pm_locals_dict, pm_locals_dict_table);
const mp_obj_module_t pm_module = {
.base = { &mp_type_module },
.globals = (mp_obj_dict_t *)&pm_locals_dict,
};
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/modpm.c | C | apache-2.0 | 6,513 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* Development of the code in this file was sponsored by Microbric Pty Ltd
* and Mnemote Pty Ltd
*
* The MIT License (MIT)
*
* Copyright (c) 2016, 2017 Nick Moore @mnemote
*
* Based on extmod/modlwip.c
* Copyright (c) 2013, 2014 Damien P. George
* Copyright (c) 2015 Galen Hazelwood
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "shared/netutils/netutils.h"
#include "py/mperrno.h"
#include "py/mphal.h"
#include "py/nlr.h"
#include "py/objlist.h"
#include "py/objstr.h"
#include "py/runtime.h"
#include "py/runtime0.h"
#include "py/stream.h"
#include "lwip/sockets.h"
#include "lwip/netdb.h"
#include "lwip/ip4.h"
#include "lwip/igmp.h"
#define SOCKET_POLL_US (100000)
#define MDNS_QUERY_TIMEOUT_MS (5000)
#define MDNS_LOCAL_SUFFIX ".local"
// add for aliosthings
#define NETUTILS_BIG 0
typedef struct _socket_obj_t {
mp_obj_base_t base;
int fd;
uint8_t domain;
uint8_t type;
uint8_t proto;
bool peer_closed;
unsigned int retries;
#if MICROPY_PY_USOCKET_EVENTS
mp_obj_t events_callback;
struct _socket_obj_t *events_next;
#endif
} socket_obj_t;
void _socket_settimeout(socket_obj_t *sock, uint64_t timeout_ms);
#if MICROPY_PY_USOCKET_EVENTS
// Support for callbacks on asynchronous socket events (when socket becomes
// readable)
// This divisor is used to reduce the load on the system, so it doesn't poll
// sockets too often
#define USOCKET_EVENTS_DIVISOR (8)
STATIC uint8_t usocket_events_divisor;
STATIC socket_obj_t *usocket_events_head = NULL;
void usocket_events_deinit(void)
{
usocket_events_head = NULL;
}
// Assumes the socket is not already in the linked list, and adds it
STATIC void usocket_events_add(socket_obj_t *sock)
{
sock->events_next = usocket_events_head;
usocket_events_head = sock;
}
// Assumes the socket is already in the linked list, and removes it
STATIC void usocket_events_remove(socket_obj_t *sock)
{
for (socket_obj_t **s = &usocket_events_head; *s != NULL; s = &(*s)->events_next) {
if (*s == sock) {
*s = (*s)->events_next;
return;
}
}
}
// Polls all registered sockets for readability and calls their callback if they
// are readable
void usocket_events_handler(void)
{
if (usocket_events_head == NULL) {
return;
}
if (--usocket_events_divisor) {
return;
}
usocket_events_divisor = USOCKET_EVENTS_DIVISOR;
fd_set rfds;
FD_ZERO(&rfds);
int max_fd = 0;
for (socket_obj_t *s = usocket_events_head; s != NULL; s = s->events_next) {
FD_SET(s->fd, &rfds);
max_fd = MAX(max_fd, s->fd);
}
// Poll the sockets
struct timeval timeout = { .tv_sec = 0, .tv_usec = 0 };
int r = select(max_fd + 1, &rfds, NULL, NULL, &timeout);
if (r <= 0) {
return;
}
// Call the callbacks
for (socket_obj_t *s = usocket_events_head; s != NULL; s = s->events_next) {
if (FD_ISSET(s->fd, &rfds)) {
mp_call_function_1_protected(s->events_callback, s);
}
}
}
#endif // MICROPY_PY_USOCKET_EVENTS
static inline void check_for_exceptions(void)
{
// mp_handle_pending(1);
}
// This function mimics lwip_getaddrinfo, with added support for mDNS queries
static int _socket_getaddrinfo3(const char *nodename, const char *servname, const struct addrinfo *hints,
struct addrinfo **res)
{
#if MICROPY_HW_ENABLE_MDNS_QUERIES
int nodename_len = strlen(nodename);
const int local_len = sizeof(MDNS_LOCAL_SUFFIX) - 1;
if (nodename_len > local_len && strcasecmp(nodename + nodename_len - local_len, MDNS_LOCAL_SUFFIX) == 0) {
// mDNS query
char nodename_no_local[nodename_len - local_len + 1];
memcpy(nodename_no_local, nodename, nodename_len - local_len);
nodename_no_local[nodename_len - local_len] = '\0';
#if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(4, 1, 0)
struct ip4_addr addr = { 0 };
#else
esp_ip4_addr_t addr = { 0 };
#endif
mp_int_t err = mdns_query_a(nodename_no_local, MDNS_QUERY_TIMEOUT_MS, &addr);
if (err != ESP_OK) {
if (err == ESP_ERR_NOT_FOUND) {
*res = NULL;
return 0;
}
*res = NULL;
return err;
}
struct addrinfo *ai = memp_malloc(MEMP_NETDB);
if (ai == NULL) {
*res = NULL;
return EAI_MEMORY;
}
memset(ai, 0, sizeof(struct addrinfo) + sizeof(struct sockaddr_storage));
struct sockaddr_in *sa = (struct sockaddr_in *)((uint8_t *)ai + sizeof(struct addrinfo));
inet_addr_from_ip4addr(&sa->sin_addr, &addr);
sa->sin_family = AF_INET;
sa->sin_len = sizeof(struct sockaddr_in);
sa->sin_port = lwip_htons((u16_t)atoi(servname));
ai->ai_family = AF_INET;
ai->ai_canonname = ((char *)sa + sizeof(struct sockaddr_storage));
memcpy(ai->ai_canonname, nodename, nodename_len + 1);
ai->ai_addrlen = sizeof(struct sockaddr_storage);
ai->ai_addr = (struct sockaddr *)sa;
*res = ai;
return 0;
}
#endif
// Normal query
return lwip_getaddrinfo(nodename, servname, hints, res);
}
static int _socket_getaddrinfo2(const mp_obj_t host, const mp_obj_t portx, struct addrinfo **resp)
{
const struct addrinfo hints = {
.ai_family = AF_INET,
.ai_socktype = SOCK_STREAM,
};
mp_obj_t port = portx;
if (mp_obj_is_small_int(port)) {
// This is perverse, because lwip_getaddrinfo promptly converts it back
// to an int, but that's the API we have to work with ...
port = mp_obj_str_binary_op(MP_BINARY_OP_MODULO, mp_obj_new_str_via_qstr("%s", 2), port);
}
const char *host_str = mp_obj_str_get_str(host);
const char *port_str = mp_obj_str_get_str(port);
if (host_str[0] == '\0') {
// a host of "" is equivalent to the default/all-local IP address
host_str = "0.0.0.0";
}
MP_THREAD_GIL_EXIT();
int res = _socket_getaddrinfo3(host_str, port_str, &hints, resp);
MP_THREAD_GIL_ENTER();
// Per docs: instead of raising gaierror getaddrinfo raises negative error
// number
if (res != 0) {
mp_raise_OSError(res > 0 ? -res : res);
}
// Somehow LwIP returns a resolution of 0.0.0.0 for failed lookups, traced
// it as far back as netconn_gethostbyname_addrtype returning OK instead of
// error.
if (*resp == NULL || (strcmp(resp[0]->ai_canonname, "0.0.0.0") == 0 && strcmp(host_str, "0.0.0.0") != 0)) {
mp_raise_OSError(-2); // name or service not known
}
return res;
}
STATIC void _socket_getaddrinfo(const mp_obj_t addrtuple, struct addrinfo **resp)
{
mp_obj_t *elem;
mp_obj_get_array_fixed_n(addrtuple, 2, &elem);
_socket_getaddrinfo2(elem[0], elem[1], resp);
}
STATIC mp_obj_t socket_make_new(const mp_obj_type_t *type_in, size_t n_args, size_t n_kw, const mp_obj_t *args)
{
mp_arg_check_num(n_args, n_kw, 0, 3, false);
socket_obj_t *sock = m_new_obj_with_finaliser(socket_obj_t);
sock->base.type = type_in;
sock->domain = AF_INET;
sock->type = SOCK_STREAM;
sock->proto = 0;
sock->peer_closed = false;
if (n_args > 0) {
sock->domain = mp_obj_get_int(args[0]);
if (n_args > 1) {
sock->type = mp_obj_get_int(args[1]);
if (n_args > 2) {
sock->proto = mp_obj_get_int(args[2]);
}
}
}
sock->fd = lwip_socket(sock->domain, sock->type, sock->proto);
if (sock->fd < 0) {
mp_raise_OSError(errno);
}
_socket_settimeout(sock, UINT64_MAX);
return MP_OBJ_FROM_PTR(sock);
}
STATIC mp_obj_t socket_bind(const mp_obj_t arg0, const mp_obj_t arg1)
{
socket_obj_t *self = MP_OBJ_TO_PTR(arg0);
struct addrinfo *res;
_socket_getaddrinfo(arg1, &res);
int r = lwip_bind(self->fd, res->ai_addr, res->ai_addrlen);
lwip_freeaddrinfo(res);
if (r < 0) {
mp_raise_OSError(errno);
}
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_bind_obj, socket_bind);
STATIC mp_obj_t socket_listen(const mp_obj_t arg0, const mp_obj_t arg1)
{
socket_obj_t *self = MP_OBJ_TO_PTR(arg0);
int backlog = mp_obj_get_int(arg1);
int r = lwip_listen(self->fd, backlog);
if (r < 0) {
mp_raise_OSError(errno);
}
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_listen_obj, socket_listen);
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(self->fd, &addr, &addr_len);
MP_THREAD_GIL_ENTER();
if (new_fd >= 0) {
break;
}
if (errno != EAGAIN) {
mp_raise_OSError(errno);
}
check_for_exceptions();
}
if (new_fd < 0) {
if (self->retries == 0) {
mp_raise_OSError(MP_EAGAIN);
} else {
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;
sock->peer_closed = false;
_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;
// modify by aliosthings
// client->items[1] = netutils_format_inet_addr(ip, port, NETUTILS_BIG);
client->items[1] = mp_const_none;
return client;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(socket_accept_obj, socket_accept);
STATIC mp_obj_t socket_connect(const mp_obj_t arg0, const mp_obj_t arg1)
{
socket_obj_t *self = MP_OBJ_TO_PTR(arg0);
struct addrinfo *res;
_socket_getaddrinfo(arg1, &res);
MP_THREAD_GIL_EXIT();
int r = lwip_connect(self->fd, res->ai_addr, res->ai_addrlen);
MP_THREAD_GIL_ENTER();
lwip_freeaddrinfo(res);
if (r != 0) {
mp_raise_OSError(errno);
}
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_connect_obj, socket_connect);
STATIC mp_obj_t socket_setsockopt(size_t n_args, const mp_obj_t *args)
{
(void)n_args; // always 4
socket_obj_t *self = MP_OBJ_TO_PTR(args[0]);
int opt = mp_obj_get_int(args[2]);
switch (opt) {
case SO_REUSEADDR:
{
int val = mp_obj_get_int(args[3]);
int ret = lwip_setsockopt(self->fd, SOL_SOCKET, opt, &val, sizeof(int));
if (ret != 0) {
mp_raise_OSError(errno);
}
break;
}
#if MICROPY_PY_USOCKET_EVENTS
// level: SOL_SOCKET
// special "register callback" option
case 20:
{
if (args[3] == mp_const_none) {
if (self->events_callback != MP_OBJ_NULL) {
usocket_events_remove(self);
self->events_callback = MP_OBJ_NULL;
}
} else {
if (self->events_callback == MP_OBJ_NULL) {
usocket_events_add(self);
}
self->events_callback = args[3];
}
break;
}
#endif
// level: IPPROTO_IP
case IP_ADD_MEMBERSHIP:
{
mp_buffer_info_t bufinfo;
mp_get_buffer_raise(args[3], &bufinfo, MP_BUFFER_READ);
if (bufinfo.len != sizeof(ip4_addr_t) * 2) {
mp_raise_ValueError(NULL);
}
// POSIX setsockopt has order: group addr, if addr, lwIP has it
// vice-versa
err_t err = igmp_joingroup((const ip4_addr_t *)bufinfo.buf + 1, bufinfo.buf);
if (err != ERR_OK) {
mp_raise_OSError(-err);
}
break;
}
default:
mp_printf(&mp_plat_print, "Warning: lwip.setsockopt() option not implemented\n");
}
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(socket_setsockopt_obj, 4, 4, socket_setsockopt);
void _socket_settimeout(socket_obj_t *sock, uint64_t timeout_ms)
{
// Rather than waiting for the entire timeout specified, we wait
// sock->retries times for SOCKET_POLL_US each, checking for a MicroPython
// interrupt between timeouts. with SOCKET_POLL_MS == 100ms, sock->retries
// allows for timeouts up to 13 years. if timeout_ms == UINT64_MAX, wait
// forever.
sock->retries = (timeout_ms == UINT64_MAX) ? UINT_MAX : timeout_ms * 1000 / SOCKET_POLL_US;
struct timeval timeout = { .tv_sec = 0, .tv_usec = timeout_ms ? SOCKET_POLL_US : 0 };
lwip_setsockopt(sock->fd, SOL_SOCKET, SO_SNDTIMEO, (const void *)&timeout, sizeof(timeout));
lwip_setsockopt(sock->fd, SOL_SOCKET, SO_RCVTIMEO, (const void *)&timeout, sizeof(timeout));
lwip_fcntl(sock->fd, F_SETFL, timeout_ms ? 0 : O_NONBLOCK);
}
STATIC mp_obj_t socket_settimeout(const mp_obj_t arg0, const mp_obj_t arg1)
{
socket_obj_t *self = MP_OBJ_TO_PTR(arg0);
if (arg1 == mp_const_none) {
_socket_settimeout(self, UINT64_MAX);
} else {
#if MICROPY_PY_BUILTINS_FLOAT
_socket_settimeout(self, (uint64_t)(mp_obj_get_float(arg1) * MICROPY_FLOAT_CONST(1000.0)));
#else
_socket_settimeout(self, mp_obj_get_int(arg1) * 1000);
#endif
}
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_settimeout_obj, socket_settimeout);
STATIC mp_obj_t socket_setblocking(const mp_obj_t arg0, const mp_obj_t arg1)
{
socket_obj_t *self = MP_OBJ_TO_PTR(arg0);
if (mp_obj_is_true(arg1)) {
_socket_settimeout(self, UINT64_MAX);
} else {
_socket_settimeout(self, 0);
}
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_setblocking_obj, socket_setblocking);
// XXX this can end up waiting a very long time if the content is dribbled in
// one character at a time, as the timeout resets each time a recvfrom succeeds
// ... this is probably not good behaviour.
STATIC mp_uint_t _socket_read_data(mp_obj_t self_in, void *buf, size_t size, struct sockaddr *from, socklen_t *from_len,
int *errcode)
{
socket_obj_t *sock = MP_OBJ_TO_PTR(self_in);
// If the peer closed the connection then the lwIP socket API will only
// return "0" once from lwip_recvfrom and then block on subsequent calls. To
// emulate POSIX behaviour, which continues to return "0" for each call on a
// closed socket, we set a flag when the peer closed the socket.
if (sock->peer_closed) {
return 0;
}
// XXX Would be nicer to use RTC to handle timeouts
for (int i = 0; i <= sock->retries; ++i) {
// Poll the socket to see if it has waiting data and only release the
// GIL if it doesn't. This ensures higher performance in the case of
// many small reads, eg for readline.
bool release_gil;
{
fd_set rfds;
FD_ZERO(&rfds);
FD_SET(sock->fd, &rfds);
struct timeval timeout = { .tv_sec = 0, .tv_usec = 0 };
int r = select(sock->fd + 1, &rfds, NULL, NULL, &timeout);
release_gil = r != 1;
}
if (release_gil) {
MP_THREAD_GIL_EXIT();
}
int r = lwip_recvfrom(sock->fd, buf, size, 0, from, from_len);
if (release_gil) {
MP_THREAD_GIL_ENTER();
}
if (r == 0) {
sock->peer_closed = true;
}
if (r >= 0) {
return r;
}
if (errno != EWOULDBLOCK) {
*errcode = errno;
return MP_STREAM_ERROR;
}
check_for_exceptions();
}
*errcode = sock->retries == 0 ? MP_EWOULDBLOCK : MP_ETIMEDOUT;
return MP_STREAM_ERROR;
}
mp_obj_t _socket_recvfrom(mp_obj_t self_in, mp_obj_t len_in, struct sockaddr *from, socklen_t *from_len)
{
size_t len = mp_obj_get_int(len_in);
vstr_t vstr;
vstr_init_len(&vstr, len);
int errcode;
mp_uint_t ret = _socket_read_data(self_in, vstr.buf, len, from, from_len, &errcode);
if (ret == MP_STREAM_ERROR) {
mp_raise_OSError(errcode);
}
vstr.len = ret;
return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
}
STATIC mp_obj_t socket_recv(mp_obj_t self_in, mp_obj_t len_in)
{
return _socket_recvfrom(self_in, len_in, NULL, NULL);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_recv_obj, socket_recv);
STATIC mp_obj_t socket_recvfrom(mp_obj_t self_in, mp_obj_t len_in)
{
struct sockaddr from;
socklen_t fromlen = sizeof(from);
mp_obj_t tuple[2];
tuple[0] = _socket_recvfrom(self_in, len_in, &from, &fromlen);
uint8_t *ip = (uint8_t *)&((struct sockaddr_in *)&from)->sin_addr;
mp_uint_t port = lwip_ntohs(((struct sockaddr_in *)&from)->sin_port);
// modify by aliosthings
// tuple[1] = netutils_format_inet_addr(ip, port, NETUTILS_BIG);
tuple[1] = mp_const_none;
return mp_obj_new_tuple(2, tuple);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_recvfrom_obj, socket_recvfrom);
int _socket_send(socket_obj_t *sock, const char *data, size_t datalen)
{
int sentlen = 0;
for (int i = 0; i <= sock->retries && sentlen < datalen; i++) {
MP_THREAD_GIL_EXIT();
int r = lwip_write(sock->fd, data + sentlen, datalen - sentlen);
MP_THREAD_GIL_ENTER();
// lwip returns EINPROGRESS when trying to send right after a
// non-blocking connect
if (r < 0 && errno != EWOULDBLOCK && errno != EINPROGRESS) {
mp_raise_OSError(errno);
}
if (r > 0) {
sentlen += r;
}
check_for_exceptions();
}
if (sentlen == 0) {
mp_raise_OSError(sock->retries == 0 ? MP_EWOULDBLOCK : MP_ETIMEDOUT);
}
return sentlen;
}
STATIC mp_obj_t socket_send(const mp_obj_t arg0, const mp_obj_t arg1)
{
socket_obj_t *sock = MP_OBJ_TO_PTR(arg0);
mp_buffer_info_t bufinfo;
mp_get_buffer_raise(arg1, &bufinfo, MP_BUFFER_READ);
int r = _socket_send(sock, bufinfo.buf, bufinfo.len);
return mp_obj_new_int(r);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_send_obj, socket_send);
STATIC mp_obj_t socket_sendall(const mp_obj_t arg0, const mp_obj_t arg1)
{
// XXX behaviour when nonblocking (see extmod/modlwip.c)
// XXX also timeout behaviour.
socket_obj_t *sock = MP_OBJ_TO_PTR(arg0);
mp_buffer_info_t bufinfo;
mp_get_buffer_raise(arg1, &bufinfo, MP_BUFFER_READ);
int r = _socket_send(sock, bufinfo.buf, bufinfo.len);
if (r < bufinfo.len) {
mp_raise_OSError(MP_ETIMEDOUT);
}
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_sendall_obj, socket_sendall);
STATIC mp_obj_t socket_sendto(mp_obj_t self_in, mp_obj_t data_in, mp_obj_t addr_in)
{
socket_obj_t *self = MP_OBJ_TO_PTR(self_in);
// get the buffer to send
mp_buffer_info_t bufinfo;
mp_get_buffer_raise(data_in, &bufinfo, MP_BUFFER_READ);
// create the destination address
struct sockaddr_in to;
to.sin_len = sizeof(to);
to.sin_family = AF_INET;
to.sin_port = lwip_htons(netutils_parse_inet_addr(addr_in, (uint8_t *)&to.sin_addr, NETUTILS_BIG));
// send the data
for (int i = 0; i <= self->retries; i++) {
MP_THREAD_GIL_EXIT();
int ret = lwip_sendto(self->fd, bufinfo.buf, bufinfo.len, 0, (struct sockaddr *)&to, sizeof(to));
MP_THREAD_GIL_ENTER();
if (ret > 0) {
return mp_obj_new_int_from_uint(ret);
}
if (ret == -1 && errno != EWOULDBLOCK) {
mp_raise_OSError(errno);
}
check_for_exceptions();
}
mp_raise_OSError(MP_ETIMEDOUT);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_3(socket_sendto_obj, socket_sendto);
STATIC mp_obj_t socket_fileno(const mp_obj_t arg0)
{
socket_obj_t *self = MP_OBJ_TO_PTR(arg0);
return mp_obj_new_int(self->fd);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(socket_fileno_obj, socket_fileno);
STATIC mp_obj_t socket_makefile(size_t n_args, const mp_obj_t *args)
{
(void)n_args;
return args[0];
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(socket_makefile_obj, 1, 3, socket_makefile);
STATIC mp_uint_t socket_stream_read(mp_obj_t self_in, void *buf, mp_uint_t size, int *errcode)
{
return _socket_read_data(self_in, buf, size, NULL, NULL, errcode);
}
STATIC mp_uint_t socket_stream_write(mp_obj_t self_in, const void *buf, mp_uint_t size, int *errcode)
{
socket_obj_t *sock = self_in;
for (int i = 0; i <= sock->retries; i++) {
MP_THREAD_GIL_EXIT();
int r = lwip_write(sock->fd, buf, size);
MP_THREAD_GIL_ENTER();
if (r > 0) {
return r;
}
// lwip returns MP_EINPROGRESS when trying to write right after a
// non-blocking connect
if (r < 0 && errno != EWOULDBLOCK && errno != EINPROGRESS) {
*errcode = errno;
return MP_STREAM_ERROR;
}
check_for_exceptions();
}
*errcode = sock->retries == 0 ? MP_EWOULDBLOCK : MP_ETIMEDOUT;
return MP_STREAM_ERROR;
}
STATIC mp_uint_t socket_stream_ioctl(mp_obj_t self_in, mp_uint_t request, uintptr_t arg, int *errcode)
{
socket_obj_t *socket = self_in;
if (request == MP_STREAM_POLL) {
if (socket->fd == -1) {
return MP_STREAM_POLL_NVAL;
}
fd_set rfds;
FD_ZERO(&rfds);
fd_set wfds;
FD_ZERO(&wfds);
fd_set efds;
FD_ZERO(&efds);
struct timeval timeout = { .tv_sec = 0, .tv_usec = 0 };
if (arg & MP_STREAM_POLL_RD) {
FD_SET(socket->fd, &rfds);
}
if (arg & MP_STREAM_POLL_WR) {
FD_SET(socket->fd, &wfds);
}
if (arg & MP_STREAM_POLL_HUP) {
FD_SET(socket->fd, &efds);
}
int r = select((socket->fd) + 1, &rfds, &wfds, &efds, &timeout);
if (r < 0) {
*errcode = MP_EIO;
return MP_STREAM_ERROR;
}
mp_uint_t ret = 0;
if (FD_ISSET(socket->fd, &rfds)) {
ret |= MP_STREAM_POLL_RD;
}
if (FD_ISSET(socket->fd, &wfds)) {
ret |= MP_STREAM_POLL_WR;
}
if (FD_ISSET(socket->fd, &efds)) {
ret |= MP_STREAM_POLL_HUP;
}
return ret;
} else if (request == MP_STREAM_CLOSE) {
if (socket->fd >= 0) {
#if MICROPY_PY_USOCKET_EVENTS
if (socket->events_callback != MP_OBJ_NULL) {
usocket_events_remove(socket);
socket->events_callback = MP_OBJ_NULL;
}
#endif
int ret = lwip_close(socket->fd);
if (ret != 0) {
*errcode = errno;
return MP_STREAM_ERROR;
}
socket->fd = -1;
}
return 0;
}
*errcode = MP_EINVAL;
return MP_STREAM_ERROR;
}
STATIC const mp_rom_map_elem_t socket_locals_dict_table[] = {
{ MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&mp_stream_close_obj) },
{ MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&mp_stream_close_obj) },
{ MP_ROM_QSTR(MP_QSTR_bind), MP_ROM_PTR(&socket_bind_obj) },
{ MP_ROM_QSTR(MP_QSTR_listen), MP_ROM_PTR(&socket_listen_obj) },
{ MP_ROM_QSTR(MP_QSTR_accept), MP_ROM_PTR(&socket_accept_obj) },
{ MP_ROM_QSTR(MP_QSTR_connect), MP_ROM_PTR(&socket_connect_obj) },
{ MP_ROM_QSTR(MP_QSTR_send), MP_ROM_PTR(&socket_send_obj) },
{ MP_ROM_QSTR(MP_QSTR_sendall), MP_ROM_PTR(&socket_sendall_obj) },
{ MP_ROM_QSTR(MP_QSTR_sendto), MP_ROM_PTR(&socket_sendto_obj) },
{ MP_ROM_QSTR(MP_QSTR_recv), MP_ROM_PTR(&socket_recv_obj) },
{ MP_ROM_QSTR(MP_QSTR_recvfrom), MP_ROM_PTR(&socket_recvfrom_obj) },
{ MP_ROM_QSTR(MP_QSTR_setsockopt), MP_ROM_PTR(&socket_setsockopt_obj) },
{ MP_ROM_QSTR(MP_QSTR_settimeout), MP_ROM_PTR(&socket_settimeout_obj) },
{ MP_ROM_QSTR(MP_QSTR_setblocking), MP_ROM_PTR(&socket_setblocking_obj) },
{ MP_ROM_QSTR(MP_QSTR_makefile), MP_ROM_PTR(&socket_makefile_obj) },
{ MP_ROM_QSTR(MP_QSTR_fileno), MP_ROM_PTR(&socket_fileno_obj) },
{ MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&mp_stream_read_obj) },
{ MP_ROM_QSTR(MP_QSTR_readinto), MP_ROM_PTR(&mp_stream_readinto_obj) },
{ MP_ROM_QSTR(MP_QSTR_readline), MP_ROM_PTR(&mp_stream_unbuffered_readline_obj) },
{ MP_ROM_QSTR(MP_QSTR_write), MP_ROM_PTR(&mp_stream_write_obj) },
};
STATIC MP_DEFINE_CONST_DICT(socket_locals_dict, socket_locals_dict_table);
STATIC const mp_stream_p_t socket_stream_p = { .read = socket_stream_read,
.write = socket_stream_write,
.ioctl = socket_stream_ioctl };
STATIC const mp_obj_type_t mp_type_socket = {
{ &mp_type_type },
.name = MP_QSTR_socket,
.make_new = socket_make_new,
.protocol = &socket_stream_p,
.locals_dict = (mp_obj_t)&socket_locals_dict,
};
STATIC mp_obj_t mod_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(mod_socket_getaddrinfo_obj, 2, 6, mod_socket_getaddrinfo);
#define BINADDR_MAX_LEN sizeof(struct in6_addr)
STATIC mp_obj_t mod_socket_inet_pton(mp_obj_t family_in, mp_obj_t addr_in)
{
int family = mp_obj_get_int(family_in);
byte binaddr[BINADDR_MAX_LEN];
int r = inet_pton(family, mp_obj_str_get_str(addr_in), binaddr);
if (r == 0) {
mp_raise_OSError(MP_EINVAL);
}
int binaddr_len = 0;
switch (family) {
case AF_INET:
binaddr_len = sizeof(struct in_addr);
break;
case AF_INET6:
binaddr_len = sizeof(struct in6_addr);
break;
}
return mp_obj_new_bytes(binaddr, binaddr_len);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_2(mod_socket_inet_pton_obj, mod_socket_inet_pton);
STATIC mp_obj_t mod_socket_inet_ntop(mp_obj_t family_in, mp_obj_t binaddr_in)
{
int family = mp_obj_get_int(family_in);
mp_buffer_info_t bufinfo;
mp_get_buffer_raise(binaddr_in, &bufinfo, MP_BUFFER_READ);
vstr_t vstr;
#if LWIP_IPV6
vstr_init_len(&vstr, family == AF_INET ? INET_ADDRSTRLEN : INET6_ADDRSTRLEN);
#else
vstr_init_len(&vstr, INET_ADDRSTRLEN);
#endif
if (inet_ntop(family, bufinfo.buf, vstr.buf, vstr.len) == NULL) {
mp_raise_OSError(errno);
}
vstr.len = strlen(vstr.buf);
return mp_obj_new_str_from_vstr(&mp_type_str, &vstr);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_2(mod_socket_inet_ntop_obj, mod_socket_inet_ntop);
STATIC mp_obj_t mod_socket_initialize()
{
static int initialized = 0;
if (!initialized) {
// modify by aliosthings
// tcpip_adapter_init();
initialized = 1;
}
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_0(mod_socket_initialize_obj, mod_socket_initialize);
STATIC mp_obj_t mod_socket_sockaddr(mp_obj_t sockaddr_in)
{
mp_buffer_info_t bufinfo;
mp_get_buffer_raise(sockaddr_in, &bufinfo, MP_BUFFER_READ);
switch (((struct sockaddr *)bufinfo.buf)->sa_family) {
case AF_INET:
{
struct sockaddr_in *sa = (struct sockaddr_in *)bufinfo.buf;
mp_obj_tuple_t *t = MP_OBJ_TO_PTR(mp_obj_new_tuple(3, NULL));
t->items[0] = MP_OBJ_NEW_SMALL_INT(AF_INET);
t->items[1] = mp_obj_new_bytes((byte *)&sa->sin_addr, sizeof(sa->sin_addr));
t->items[2] = MP_OBJ_NEW_SMALL_INT(ntohs(sa->sin_port));
return MP_OBJ_FROM_PTR(t);
}
#if LWIP_IPV6
case AF_INET6:
{
struct sockaddr_in6 *sa = (struct sockaddr_in6 *)bufinfo.buf;
mp_obj_tuple_t *t = MP_OBJ_TO_PTR(mp_obj_new_tuple(5, NULL));
t->items[0] = MP_OBJ_NEW_SMALL_INT(AF_INET6);
t->items[1] = mp_obj_new_bytes((byte *)&sa->sin6_addr, sizeof(sa->sin6_addr));
t->items[2] = MP_OBJ_NEW_SMALL_INT(ntohs(sa->sin6_port));
t->items[3] = MP_OBJ_NEW_SMALL_INT(ntohl(sa->sin6_flowinfo));
t->items[4] = MP_OBJ_NEW_SMALL_INT(ntohl(sa->sin6_scope_id));
return MP_OBJ_FROM_PTR(t);
}
#endif
default:
{
struct sockaddr *sa = (struct sockaddr *)bufinfo.buf;
mp_obj_tuple_t *t = MP_OBJ_TO_PTR(mp_obj_new_tuple(2, NULL));
t->items[0] = MP_OBJ_NEW_SMALL_INT(sa->sa_family);
t->items[1] = mp_obj_new_bytes((byte *)sa->sa_data, bufinfo.len - offsetof(struct sockaddr, sa_data));
return MP_OBJ_FROM_PTR(t);
}
}
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(mod_socket_sockaddr_obj, mod_socket_sockaddr);
STATIC const mp_rom_map_elem_t mp_module_socket_globals_table[] = {
{ MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_usocket) },
{ MP_ROM_QSTR(MP_QSTR___init__), MP_ROM_PTR(&mod_socket_initialize_obj) },
{ MP_ROM_QSTR(MP_QSTR_socket), MP_ROM_PTR(&mp_type_socket) },
{ MP_ROM_QSTR(MP_QSTR_getaddrinfo), MP_ROM_PTR(&mod_socket_getaddrinfo_obj) },
{ MP_ROM_QSTR(MP_QSTR_inet_pton), MP_ROM_PTR(&mod_socket_inet_pton_obj) },
{ MP_ROM_QSTR(MP_QSTR_inet_ntop), MP_ROM_PTR(&mod_socket_inet_ntop_obj) },
{ MP_ROM_QSTR(MP_QSTR_sockaddr), MP_ROM_PTR(&mod_socket_sockaddr_obj) },
{ MP_ROM_QSTR(MP_QSTR_AF_INET), MP_ROM_INT(AF_INET) },
{ MP_ROM_QSTR(MP_QSTR_AF_INET6), MP_ROM_INT(AF_INET6) },
{ MP_ROM_QSTR(MP_QSTR_SOCK_STREAM), MP_ROM_INT(SOCK_STREAM) },
{ MP_ROM_QSTR(MP_QSTR_SOCK_DGRAM), MP_ROM_INT(SOCK_DGRAM) },
{ MP_ROM_QSTR(MP_QSTR_SOCK_RAW), MP_ROM_INT(SOCK_RAW) },
{ MP_ROM_QSTR(MP_QSTR_IPPROTO_TCP), MP_ROM_INT(IPPROTO_TCP) },
{ MP_ROM_QSTR(MP_QSTR_IPPROTO_UDP), MP_ROM_INT(IPPROTO_UDP) },
{ MP_ROM_QSTR(MP_QSTR_IPPROTO_IP), MP_ROM_INT(IPPROTO_IP) },
{ MP_ROM_QSTR(MP_QSTR_SOL_SOCKET), MP_ROM_INT(SOL_SOCKET) },
{ MP_ROM_QSTR(MP_QSTR_SO_REUSEADDR), MP_ROM_INT(SO_REUSEADDR) },
{ MP_ROM_QSTR(MP_QSTR_IP_ADD_MEMBERSHIP), MP_ROM_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,
};
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/modsocket.c | C | apache-2.0 | 32,806 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "py/builtin.h"
#include "py/mperrno.h"
#include "py/obj.h"
#include "py/runtime.h"
#include "ulog/ulog.h"
#define LOG_TAG "MOD_SYSTEMINFO"
// this is the actual C-structure for our new object
typedef struct {
// base represents some basic information, like type
mp_obj_base_t Base;
// a member created by us
char *ModuleName;
} mp_system_obj_t;
STATIC mp_obj_t obj_open(size_t n_args, const mp_obj_t *args)
{
LOGD(LOG_TAG, "entern %s; n_args = %d;\n", __func__, n_args);
int ret = -1;
void *instance = NULL;
if (n_args < 1) {
LOGE(LOG_TAG, "%s: args num is illegal :n_args = %d;\n", __func__,
n_args);
return mp_const_none;
}
LOGD(LOG_TAG, "%s:out\n", __func__);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR(system_obj_open, 1, obj_open);
STATIC mp_obj_t obj_close(size_t n_args, const mp_obj_t *args)
{
LOGD(LOG_TAG, "entern %s; n_args = %d;\n", __func__, n_args);
int ret = -1;
void *instance = NULL;
if (n_args < 1) {
LOGE(LOG_TAG, "%s: args num is illegal :n_args = %d;\n", __func__,
n_args);
return mp_const_none;
}
LOGD(LOG_TAG, "%s:out\n", __func__);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR(system_obj_close, 1, obj_close);
STATIC mp_obj_t obj_versions(size_t n_args, const mp_obj_t *args)
{
LOGD(LOG_TAG, "entern %s; n_args = %d;\n", __func__, n_args);
int ret = -1;
char *version = NULL;
if (n_args < 1) {
LOGE(LOG_TAG, "%s: args num is illegal :n_args = %d;\n", __func__,
n_args);
return mp_const_none;
}
// version = amp_get_system_version();
LOGD(LOG_TAG, "%s:out\n", __func__);
return MP_ROM_QSTR(version);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR(system_obj_versions, 1, obj_versions);
STATIC mp_obj_t obj_version(size_t n_args, const mp_obj_t *args)
{
LOGD(LOG_TAG, "entern %s; n_args = %d;\n", __func__, n_args);
int ret = -1;
// char version[AMP_VERSION_LENGTH] = {0};
if (n_args < 1) {
LOGE(LOG_TAG, "%s: args num is illegal :n_args = %d;\n", __func__,
n_args);
return mp_const_none;
}
// amp_version_get(version);
LOGD(LOG_TAG, "%s:out\n", __func__);
// return MP_ROM_QSTR(version);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR(system_obj_version, 1, obj_version);
STATIC mp_obj_t obj_platform(size_t n_args, const mp_obj_t *args)
{
LOGD(LOG_TAG, "entern %s; n_args = %d;\n", __func__, n_args);
int ret = -1;
char *type = NULL;
if (n_args < 1) {
LOGE(LOG_TAG, "%s: args num is illegal :n_args = %d;\n", __func__,
n_args);
return mp_const_none;
}
// type = amp_get_platform_type();
LOGD(LOG_TAG, "%s:out\n", __func__);
return MP_ROM_QSTR(type);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR(system_obj_platform, 1, obj_platform);
STATIC mp_obj_t obj_uptime(size_t n_args, const mp_obj_t *args)
{
LOGD(LOG_TAG, "entern %s; n_args = %d;\n", __func__, n_args);
int ret = -1;
if (n_args < 1) {
LOGE(LOG_TAG, "%s: args num is illegal :n_args = %d;\n", __func__,
n_args);
return mp_const_none;
}
// ret = amp_uptime();
LOGD(LOG_TAG, "%s:out\n", __func__);
return MP_ROM_INT(ret);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR(system_obj_uptime, 1, obj_uptime);
STATIC mp_obj_t obj_memory_total(size_t n_args, const mp_obj_t *args)
{
LOGD(LOG_TAG, "entern %s; n_args = %d;\n", __func__, n_args);
int ret = -1;
// amp_heap_info_t heap_info;
if (n_args < 1) {
LOGE(LOG_TAG, "%s: args num is illegal :n_args = %d;\n", __func__,
n_args);
return mp_const_none;
}
// ret = amp_heap_memory_info(&heap_info);
if (ret != 0) {
LOGE(LOG_TAG, "%s:amp_heap_memory_info failed\n", __func__);
return mp_const_none;
}
// LOGD(LOG_TAG, "%s:heap_info.heap_total = %d;\n", __func__,
// heap_info.heap_total); LOGD(LOG_TAG, "%s:heap_info.heap_used = %d;\n",
// __func__, heap_info.heap_used);
LOGD(LOG_TAG, "%s:out\n", __func__);
// return MP_ROM_INT(heap_info.heap_total);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR(system_obj_memory_total, 1,
obj_memory_total);
STATIC mp_obj_t obj_memory_used(size_t n_args, const mp_obj_t *args)
{
LOGD(LOG_TAG, "entern %s; n_args = %d;\n", __func__, n_args);
int ret = -1;
// amp_heap_info_t heap_info;
if (n_args < 1) {
LOGE(LOG_TAG, "%s: args num is illegal :n_args = %d;\n", __func__,
n_args);
return mp_const_none;
}
// ret = amp_heap_memory_info(&heap_info);
if (ret != 0) {
LOGE(LOG_TAG, "%s:amp_heap_memory_info failed\n", __func__);
return mp_const_none;
}
// LOGD(LOG_TAG, "%s:heap_info.heap_total = %d;\n", __func__,
// heap_info.heap_total); LOGD(LOG_TAG, "%s:heap_info.heap_used = %d;\n",
// __func__, heap_info.heap_used);
LOGD(LOG_TAG, "%s:out\n", __func__);
// return MP_ROM_INT(heap_info.heap_used);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR(system_obj_memory_used, 1, obj_memory_used);
STATIC mp_obj_t obj_gc(size_t n_args, const mp_obj_t *args)
{
LOGD(LOG_TAG, "entern %s; n_args = %d;\n", __func__, n_args);
int ret = -1;
void *instance = NULL;
if (n_args < 1) {
LOGE(LOG_TAG, "%s: args num is illegal :n_args = %d;\n", __func__,
n_args);
return mp_const_none;
}
LOGD(LOG_TAG, "%s:out\n", __func__);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR(system_obj_gc, 1, obj_gc);
STATIC const mp_rom_map_elem_t systeminfo_locals_dict_table[] = {
{ MP_OBJ_NEW_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_SystemInfo) },
{ MP_ROM_QSTR(MP_QSTR_open), MP_ROM_PTR(&system_obj_open) },
{ MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&system_obj_close) },
{ MP_ROM_QSTR(MP_QSTR_versions), MP_ROM_PTR(&system_obj_versions) },
{ MP_ROM_QSTR(MP_QSTR_version), MP_ROM_PTR(&system_obj_version) },
{ MP_ROM_QSTR(MP_QSTR_platform), MP_ROM_PTR(&system_obj_platform) },
{ MP_ROM_QSTR(MP_QSTR_uptime), MP_ROM_PTR(&system_obj_uptime) },
{ MP_ROM_QSTR(MP_QSTR_memory_total), MP_ROM_PTR(&system_obj_memory_total) },
{ MP_ROM_QSTR(MP_QSTR_memory_used), MP_ROM_PTR(&system_obj_memory_used) },
{ MP_ROM_QSTR(MP_QSTR_gc), MP_ROM_PTR(&system_obj_gc) },
};
STATIC MP_DEFINE_CONST_DICT(systeminfo_locals_dict,
systeminfo_locals_dict_table);
const mp_obj_module_t system_info_module = {
.base = { &mp_type_module },
.globals = (mp_obj_dict_t *)&systeminfo_locals_dict,
};
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/modsysteminfo.c | C | apache-2.0 | 6,773 |
import gc
import uos
from flashbdev import bdev
try:
if bdev:
uos.mount(bdev, "/")
except OSError:
import inisetup
vfs = inisetup.setup()
gc.collect()
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/modules/_boot.py | Python | apache-2.0 | 174 |
# APA106driver for MicroPython on ESP32
# MIT license; Copyright (c) 2016 Damien P. George
from neopixel import NeoPixel
class APA106(NeoPixel):
ORDER = (0, 1, 2, 3)
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/modules/apa106.py | Python | apache-2.0 | 173 |
from esp32 import Partition
bdev = Partition.find(Partition.TYPE_DATA, label="vfs")
bdev = bdev[0] if bdev else None
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/modules/flashbdev.py | Python | apache-2.0 | 118 |
import uos
from flashbdev import bdev
def check_bootsec():
buf = bytearray(bdev.ioctl(5, 0)) # 5 is SEC_SIZE
bdev.readblocks(0, buf)
empty = True
for b in buf:
if b != 0xFF:
empty = False
break
if empty:
return True
fs_corrupted()
def fs_corrupted():
import time
while 1:
print(
"""\
The filesystem appears to be corrupted. If you had important data there, you
may want to make a flash snapshot to try to recover it. Otherwise, perform
factory reprogramming of MicroPython firmware (completely erase flash, followed
by firmware programming).
"""
)
time.sleep(3)
def setup():
check_bootsec()
print("Performing initial setup")
uos.VfsLfs2.mkfs(bdev)
vfs = uos.VfsLfs2(bdev)
uos.mount(vfs, "/")
with open("boot.py", "w") as f:
f.write(
"""\
# This file is executed on every boot (including wake-boot from deepsleep)
#import esp
#esp.osdebug(None)
#import webrepl
#webrepl.start()
"""
)
return vfs
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/modules/inisetup.py | Python | apache-2.0 | 1,066 |
try:
import usocket as socket
except:
import socket
try:
import ustruct as struct
except:
import struct
# (date(2000, 1, 1) - date(1900, 1, 1)).days * 24*60*60
NTP_DELTA = 3155673600
# The NTP host can be configured at runtime by doing: ntptime.host = 'myhost.org'
host = "pool.ntp.org"
def time():
NTP_QUERY = bytearray(48)
NTP_QUERY[0] = 0x1B
addr = socket.getaddrinfo(host, 123)[0][-1]
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
try:
s.settimeout(1)
res = s.sendto(NTP_QUERY, addr)
msg = s.recv(48)
finally:
s.close()
val = struct.unpack("!I", msg[40:44])[0]
return val - NTP_DELTA
# There's currently no timezone support in MicroPython, and the RTC is set in UTC time.
def settime():
t = time()
import machine
import utime
tm = utime.gmtime(t)
machine.RTC().datetime((tm[0], tm[1], tm[2], tm[6] + 1, tm[3], tm[4], tm[5], 0))
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/modules/ntptime.py | Python | apache-2.0 | 946 |
from minicv import ML
AI_ENGINE_ALIYUN = 1
AI_ENGINE_NATIVE = 2
class AI:
def __init__(self, type=AI_ENGINE_NATIVE, accessKey=None, accessSecret=None, ossEndpoint=None, ossBucket=None):
self.type = type
self.ml = ML()
if (self.type == AI_ENGINE_ALIYUN):
self.ml.open(self.ml.ML_ENGINE_CLOUD)
if not accessKey or not accessSecret:
print('access key can not be null')
return
else:
self.ml.config(accessKey, accessSecret, ossEndpoint, ossBucket)
else:
print('now only support cloud ai, not support nativate ai yet')
print("Please use example: ai = AI(AI.AI_ENGINE_CLOUD, 'Your-Access-Key', 'Your-Access-Secret')")
# 人脸比对
def compareFace(self, imagePath, compareFacePath):
self.ml.setInputData(imagePath, compareFacePath)
self.ml.loadNet("FacebodyComparing")
self.ml.predict()
resp = self.ml.getPredictResponses(None)
self.ml.unLoadNet()
return resp
# 人体检测
def detectPedestrian(self, imagePath):
self.ml.setInputData(imagePath)
self.ml.loadNet("DetectPedestrian")
self.ml.predict()
resp = self.ml.getPredictResponses(None)
self.ml.unLoadNet()
return resp
# 水果检测
def detectFruits(self, imagePath):
self.ml.setInputData(imagePath, None)
self.ml.loadNet("DetectFruits")
self.ml.predict()
resp = self.ml.getPredictResponses(None)
self.ml.unLoadNet()
return resp
# 车牌识别
def recognizeLicensePlate(self, imagePath):
self.ml.setInputData(imagePath)
self.ml.loadNet("RecognizeLicensePlate")
self.ml.predict()
resp = self.ml.getPredictResponses(None)
self.ml.unLoadNet()
return resp
def __del__(self):
try:
self.ml.close()
del self.type
del self.ml
except Exception:
pass
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/modules/uai.py | Python | apache-2.0 | 2,033 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2014-2018 Paul Sokolovsky
* Copyright (c) 2014-2018 Damien P. George
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <dirent.h>
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/statfs.h>
#include <sys/types.h>
#include <unistd.h>
#include "aos/kernel.h"
#include "dirent.h"
#include "extmod/misc.h"
#include "extmod/vfs.h"
#include "genhdr/mpversion.h"
#include "py/mpconfig.h"
#include "py/mperrno.h"
#include "py/mphal.h"
#include "py/mpthread.h"
#include "py/objstr.h"
#include "py/objtuple.h"
#include "py/runtime.h"
#include "ulog/ulog.h"
#include "diskio.h"
#if MICROPY_VFS_POSIX
#include "extmod/vfs_posix.h"
#endif
#define LOG_TAG "MOD_OS"
extern const mp_obj_type_t mp_fat_vfs_type;
STATIC const qstr os_uname_info_fields[] = { MP_QSTR_sysname, MP_QSTR_nodename,
MP_QSTR_release, MP_QSTR_version,
MP_QSTR_machine };
STATIC const MP_DEFINE_STR_OBJ(os_uname_info_sysname_obj,
MICROPY_PY_SYS_PLATFORM);
STATIC const MP_DEFINE_STR_OBJ(os_uname_info_nodename_obj, MICROPY_PY_SYS_NODE);
STATIC const MP_DEFINE_STR_OBJ(os_uname_info_release_obj,
MICROPY_VERSION_STRING);
STATIC const MP_DEFINE_STR_OBJ(os_uname_info_version_obj,
MICROPY_GIT_TAG " on " MICROPY_BUILD_DATE);
STATIC const MP_DEFINE_STR_OBJ(os_uname_info_machine_obj, MICROPY_HW_BOARD_NAME
" with " MICROPY_HW_MCU_NAME);
STATIC MP_DEFINE_ATTRTUPLE(os_uname_info_obj, os_uname_info_fields, 5,
(mp_obj_t)&os_uname_info_sysname_obj,
(mp_obj_t)&os_uname_info_nodename_obj,
(mp_obj_t)&os_uname_info_release_obj,
(mp_obj_t)&os_uname_info_version_obj,
(mp_obj_t)&os_uname_info_machine_obj);
STATIC mp_obj_t os_uname(void)
{
return (mp_obj_t)&os_uname_info_obj;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_0(os_uname_obj, os_uname);
STATIC mp_obj_t os_version(void)
{
char version[40] = { 0 };
sprintf(version, "%s-v%s", MICROPY_SW_VENDOR_NAME, SYSINFO_SYSTEM_VERSION);
return mp_obj_new_str(version, strlen(version));
}
STATIC MP_DEFINE_CONST_FUN_OBJ_0(os_version_obj, os_version);
STATIC mp_obj_t os_version_info(void)
{
char version_info[80] = { 0 };
#ifdef MICROPY_HW_BOARD_TYPE
sprintf(version_info, "%s-%s-%s-v%s-%s", MICROPY_SW_VENDOR_NAME, MICROPY_HW_MCU_NAME, MICROPY_HW_BOARD_TYPE,
SYSINFO_SYSTEM_VERSION, MICROPY_BUILD_DATE);
#else
sprintf(version_info, "%s-%s-v%s-%s", MICROPY_SW_VENDOR_NAME, MICROPY_HW_MCU_NAME, SYSINFO_SYSTEM_VERSION,
MICROPY_BUILD_DATE);
#endif
return mp_obj_new_str(version_info, strlen(version_info));
}
STATIC MP_DEFINE_CONST_FUN_OBJ_0(os_version_info_obj, os_version_info);
STATIC mp_obj_t os_urandom(mp_obj_t num)
{
mp_int_t n = mp_obj_get_int(num);
vstr_t vstr;
vstr_init_len(&vstr, n);
mp_uint_t r = 0;
for (int i = 0; i < n; i++) {
if ((i & 3) == 0) {
r = aos_rand(); // returns 32-bit random number
}
vstr.buf[i] = r;
r >>= 8;
}
vstr.buf[n] = '\0';
return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(os_urandom_obj, os_urandom);
static int up_one_level(char *s)
{
char *tail;
if (!s)
return -1;
tail = s + strlen(s) - 1;
if (*tail == '/')
tail--;
while (*tail != '\0' && *tail != '/')
tail--;
if (*tail == '\0') {
return -1;
} else {
*(tail + 1) = '\0';
return 0;
}
}
char *py_get_realpath(const char *path, char *resolved_path, unsigned int len)
{
char *ret, *p = (char *)path, *r = resolved_path;
if (!path || !r || len < 1)
return NULL;
memset(r, 0, len);
// deal with heading char
if (p[0] != '/') {
// relative path
ret = getcwd(r, len);
if (!ret)
return NULL;
// add tailing '/' if no
if (r[strlen(r) - 1] != '/') {
r[strlen(r)] = '/';
}
r += strlen(r);
} else {
// absolute path
r[0] = '/';
r++;
}
// iterate to exclude '.', '..'. '/'
while (*p != '\0') {
while (*p == '/')
p++;
if (*p == '\0')
break;
if (*p == '.') {
p++;
// end with '.'
if (*p == '\0')
break;
if (*p == '.') {
// '..' or '../'
if ((*(p + 1) != '/') && (*(p + 1) != '\0')) {
printf("Invalid path %s\r\n", path);
return NULL;
} else {
// '..' case
p++;
// if (*p == '/') {
if (up_one_level(resolved_path) != 0) {
printf("Failed to go up now. Invalid path %s\r\n",
path);
return NULL;
}
r = resolved_path + strlen(resolved_path);
// }
// end with '.'
if (*p == '\0') {
break;
}
}
} else {
if ((*p != '/') && (*p != '\0')) {
printf("Invalid path %s\r\n", path);
return NULL;
} else {
// '.' case
p++;
}
}
}
while (*p == '/')
p++;
if (*p == '\0')
break;
// if another round of ./.., just continue
if (*p == '.')
continue;
// path string may be found now, save to r
while ((*p != '/') && (*p != '\0'))
*r++ = *p++;
// add taling '/' if necessary
if (*(r - 1) != '/') {
*r++ = '/';
}
}
// exclude the tailing '/', just in case it is a file
if ((resolved_path[strlen(resolved_path) - 1] == '/') &&
(strlen(resolved_path) != 1)) {
resolved_path[strlen(resolved_path) - 1] = '\0';
}
return resolved_path;
}
STATIC mp_obj_t mod_os_stat(mp_obj_t path_in)
{
struct stat sb;
const char *path = mp_obj_str_get_str(path_in);
int res = stat(path, &sb);
mp_obj_tuple_t *t = MP_OBJ_TO_PTR(mp_obj_new_tuple(10, NULL));
t->items[0] = MP_OBJ_NEW_SMALL_INT(sb.st_mode);
t->items[1] = mp_obj_new_int_from_uint(sb.st_ino);
t->items[2] = mp_obj_new_int_from_uint(sb.st_dev);
t->items[3] = mp_obj_new_int_from_uint(sb.st_nlink);
t->items[4] = mp_obj_new_int_from_uint(sb.st_uid);
t->items[5] = mp_obj_new_int_from_uint(sb.st_gid);
t->items[6] = mp_obj_new_int_from_uint(sb.st_size);
t->items[7] = mp_obj_new_int_from_uint(sb.st_atime);
t->items[8] = mp_obj_new_int_from_uint(sb.st_mtime);
t->items[9] = mp_obj_new_int_from_uint(sb.st_ctime);
return MP_OBJ_FROM_PTR(t);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(mod_os_stat_obj, mod_os_stat);
STATIC mp_obj_t mod_os_statvfs(mp_obj_t path_in)
{
struct statfs sb;
const char *path = mp_obj_str_get_str(path_in);
int res = statfs(path, &sb);
mp_obj_tuple_t *t = MP_OBJ_TO_PTR(mp_obj_new_tuple(9, NULL));
t->items[0] = MP_OBJ_NEW_SMALL_INT(sb.f_type);
t->items[1] = MP_OBJ_NEW_SMALL_INT(sb.f_bsize);
t->items[2] = MP_OBJ_NEW_SMALL_INT(sb.f_blocks);
t->items[3] = MP_OBJ_NEW_SMALL_INT(sb.f_bfree);
t->items[4] = MP_OBJ_NEW_SMALL_INT(sb.f_bavail);
t->items[5] = MP_OBJ_NEW_SMALL_INT(sb.f_files);
t->items[6] = MP_OBJ_NEW_SMALL_INT(sb.f_ffree);
t->items[7] = MP_OBJ_NEW_SMALL_INT(sb.f_fsid);
t->items[8] = MP_OBJ_NEW_SMALL_INT(sb.f_namelen);
return MP_OBJ_FROM_PTR(t);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(mod_os_statvfs_obj, mod_os_statvfs);
STATIC mp_obj_t mod_os_remove(mp_obj_t path_in)
{
const char *path = mp_obj_str_get_str(path_in);
char abspath[256] = { 0 };
path = py_get_realpath(path, abspath, sizeof(abspath));
MP_THREAD_GIL_EXIT();
int r = unlink(path);
MP_THREAD_GIL_ENTER();
return MP_OBJ_NEW_SMALL_INT(r);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(mod_os_remove_obj, mod_os_remove);
static int py_mv(char *from, char *to)
{
int fd_from = 0, fd_to = 0;
char buf[128] = { 0 };
int rlen = 0, wlen = 0, ret = -1, isdir = false;
struct stat s;
char abspath_from[256] = { 0 }, abspath_to[256] = { 0 };
from = py_get_realpath(from, abspath_from, sizeof(abspath_from));
to = py_get_realpath(to, abspath_to, sizeof(abspath_to));
if (!from || !to) {
LOGE(LOG_TAG, "Failed to get real path!\r\n");
return -1;
}
if (!stat(to, &s)) {
if (S_ISDIR(s.st_mode)) {
char *p = strrchr(from, '/');
if (!p)
ret = asprintf(&to, "%s/%s", to, from);
else
ret = asprintf(&to, "%s%s", to, p);
if (ret < 0) {
LOGE(LOG_TAG, "asprintf failed\n");
return -1;
}
isdir = true;
}
}
ret = rename(from, to);
if (ret < 0 && errno != EXDEV) {
LOGE(LOG_TAG, "rename %s to %s failed - %s\n", from, to,
strerror(errno));
return -1;
} else if (ret == 0) {
return 0;
}
fd_from = open(from, O_RDONLY);
if (fd_from < 0) {
LOGE(LOG_TAG, "open %s failed - %s\n", from, strerror(errno));
return -1;
}
fd_to = open(to, O_WRONLY | O_CREAT | O_TRUNC);
if (fd_to < 0) {
LOGE(LOG_TAG, "open %s failed - %s\n", to, strerror(errno));
goto close_from;
}
while ((rlen = read(fd_from, buf, 128))) {
if (rlen < 0) {
LOGE(LOG_TAG, "read %s failed - %s\n", from, strerror(errno));
goto close_to;
}
wlen = write(fd_to, buf, rlen);
if (wlen != rlen) {
LOGE(LOG_TAG, "write %s failed - %s\n", to, strerror(errno));
goto close_to;
}
}
ret = unlink(from);
if (ret) {
LOGE(LOG_TAG, "unlink %s failed - %s\n", from, strerror(errno));
goto close_to;
}
ret = 0;
close_to:
close(fd_to);
close_from:
close(fd_from);
if (isdir)
free(to);
return ret;
}
STATIC mp_obj_t mod_os_rename(mp_obj_t old_path_in, mp_obj_t new_path_in)
{
const char *old_path = mp_obj_str_get_str(old_path_in);
const char *new_path = mp_obj_str_get_str(new_path_in);
MP_THREAD_GIL_EXIT();
int r = rename(old_path, new_path);
MP_THREAD_GIL_ENTER();
return MP_OBJ_NEW_SMALL_INT(r);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_2(mod_os_rename_obj, mod_os_rename);
int py_rrmdir(const char *path)
{
struct stat s;
DIR *pdir = NULL;
struct dirent *entry = NULL;
int ret = -1;
char *dir, *p;
if (!path)
return -EINVAL;
dir = strdup(path);
p = dir + strlen(dir) - 1;
while ((*p == '/') && (p > dir)) {
*p = '\0';
p--;
}
if (stat(dir, &s) || !S_ISDIR(s.st_mode)) {
// LOGE(LOG_TAG, "%s is neither existed nor a directory\n", dir);
goto out;
}
pdir = opendir(dir);
if (!pdir) {
LOGE(LOG_TAG, "opendir %s failed - %s\n", dir, strerror(errno));
goto out;
}
ret = 0;
while ((ret == 0) && (entry = readdir(pdir))) {
char fpath[128];
snprintf(fpath, 128, "%s/%s", dir, entry->d_name);
ret = stat(fpath, &s);
if (ret) {
LOGE(LOG_TAG, "stat %s failed\n", fpath);
break;
}
if (!strcmp(entry->d_name, "."))
continue;
if (!strcmp(entry->d_name, ".."))
continue;
if (S_ISDIR(s.st_mode))
ret = py_rrmdir(fpath);
else
ret = unlink(fpath);
}
closedir(pdir);
if (ret == 0) {
ret = rmdir(dir);
if (ret)
LOGE(LOG_TAG, "rmdir %s failed\n", dir);
}
out:
free(dir);
return ret;
}
STATIC mp_obj_t mod_os_rmdir(mp_obj_t path_in)
{
const char *path = mp_obj_str_get_str(path_in);
char abspath[256] = { 0 };
path = py_get_realpath(path, abspath, sizeof(abspath));
MP_THREAD_GIL_EXIT();
int r = rrmdir(path);
MP_THREAD_GIL_ENTER();
return MP_OBJ_NEW_SMALL_INT(r);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(mod_os_rmdir_obj, mod_os_rmdir);
STATIC mp_obj_t mod_os_system(mp_obj_t cmd_in)
{
const char *cmd = mp_obj_str_get_str(cmd_in);
MP_THREAD_GIL_EXIT();
int r = system(cmd);
MP_THREAD_GIL_ENTER();
return MP_OBJ_NEW_SMALL_INT(r);
}
MP_DEFINE_CONST_FUN_OBJ_1(mod_os_system_obj, mod_os_system);
STATIC mp_obj_t mod_os_getenv(mp_obj_t var_in)
{
const char *s = getenv(mp_obj_str_get_str(var_in));
if (s == NULL) {
return mp_const_none;
}
return mp_obj_new_str(s, strlen(s));
}
MP_DEFINE_CONST_FUN_OBJ_1(mod_os_getenv_obj, mod_os_getenv);
STATIC mp_obj_t mod_os_putenv(mp_obj_t key_in, mp_obj_t value_in)
{
const char *key = mp_obj_str_get_str(key_in);
const char *value = mp_obj_str_get_str(value_in);
int ret = setenv(key, value, 1);
if (ret == -1) {
mp_raise_OSError(errno);
}
return MP_OBJ_NEW_SMALL_INT(ret);
}
MP_DEFINE_CONST_FUN_OBJ_2(mod_os_putenv_obj, mod_os_putenv);
STATIC mp_obj_t mod_os_unsetenv(mp_obj_t key_in)
{
const char *key = mp_obj_str_get_str(key_in);
int ret = unsetenv(key);
if (ret == -1) {
mp_raise_OSError(errno);
}
return MP_OBJ_NEW_SMALL_INT(ret);
}
MP_DEFINE_CONST_FUN_OBJ_1(mod_os_unsetenv_obj, mod_os_unsetenv);
static int py_mkdir_do(const char *path, int flags)
{
char *s = NULL;
char abspath[256] = { 0 };
#define MKDIR_FLAGS_PARENTS (1 << 0)
path = py_get_realpath(path, abspath, sizeof(abspath));
if (!path) {
LOGE(LOG_TAG, "Failed to get real path!\r\n");
return -1;
}
/*
* All of operations must base on root directory
* As alios has not root dierctory, we can operate '/data' but not '/'
*/
#define MOUNT_BASE_DIR "/"
if (strncmp(path, MOUNT_BASE_DIR, strlen(MOUNT_BASE_DIR))) {
LOGE(LOG_TAG, "make directory must base on %s\n", MOUNT_BASE_DIR);
return -1;
}
if (path[0] == '.') {
if (path[1] == '\0')
return 0;
if (path[1] == '.' && path[2] == '\0')
return 0;
}
if (flags & MKDIR_FLAGS_PARENTS)
s = path + strlen(MOUNT_BASE_DIR);
while (1) {
struct stat st;
if (flags & MKDIR_FLAGS_PARENTS) {
/* in case of tailing '/', such as '/data/a/' */
if (*(s++) == '\0')
break;
s = strchr(s, '/');
if (s)
*s = '\0';
}
if (!stat(path, &st)) {
if (S_ISDIR(st.st_mode))
goto next;
LOGE(LOG_TAG,
"make failed - %s already existed and not direcotry\n", path);
return -1;
}
if (mkdir(path, 0777) < 0) {
LOGE(LOG_TAG, "mkdir %s failed\n", path);
return -1;
}
next:
if (!s)
break;
*s = '/';
}
return 0;
}
STATIC mp_obj_t mod_os_mkdir(mp_obj_t path_in)
{
// TODO: Accept mode param
const char *path = mp_obj_str_get_str(path_in);
MP_THREAD_GIL_EXIT();
int r = py_mkdir_do(path, 0777);
MP_THREAD_GIL_ENTER();
return mp_obj_new_int(r);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(mod_os_mkdir_obj, mod_os_mkdir);
typedef struct _mp_obj_listdir_t {
mp_obj_base_t base;
mp_fun_1_t iternext;
DIR *dir;
} mp_obj_listdir_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;
}
MP_THREAD_GIL_EXIT();
struct dirent *dirent = readdir(self->dir);
if (dirent == NULL) {
closedir(self->dir);
MP_THREAD_GIL_ENTER();
self->dir = NULL;
done:
return MP_OBJ_STOP_ITERATION;
}
MP_THREAD_GIL_ENTER();
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));
#ifdef _DIRENT_HAVE_D_TYPE
#ifdef DTTOIF
t->items[1] = MP_OBJ_NEW_SMALL_INT(DTTOIF(dirent->d_type));
#else
if (dirent->d_type == DT_DIR) {
t->items[1] = MP_OBJ_NEW_SMALL_INT(MP_S_IFDIR);
} else if (dirent->d_type == DT_REG) {
t->items[1] = MP_OBJ_NEW_SMALL_INT(MP_S_IFREG);
} else {
t->items[1] = MP_OBJ_NEW_SMALL_INT(dirent->d_type);
}
#endif
#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 mod_os_ilistdir(size_t n_args, const mp_obj_t *args)
{
const char *path = ".";
if (n_args > 0) {
path = mp_obj_str_get_str(args[0]);
}
char abspath[256] = { 0 };
path = py_get_realpath(path, abspath, sizeof(abspath));
mp_obj_listdir_t *o = m_new_obj(mp_obj_listdir_t);
o->base.type = &mp_type_polymorph_iter;
MP_THREAD_GIL_EXIT();
o->dir = opendir(path);
MP_THREAD_GIL_ENTER();
o->iternext = listdir_next;
return MP_OBJ_FROM_PTR(o);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mod_os_ilistdir_obj, 0, 1,
mod_os_ilistdir);
STATIC mp_obj_t mod_os_listdir(size_t n_args, const mp_obj_t *args)
{
const char *path = ".";
if (n_args > 0) {
path = mp_obj_str_get_str(args[0]);
}
mp_raise_OSError(EPERM);
return mp_const_none;
mp_obj_listdir_t *o = m_new_obj(mp_obj_listdir_t);
MP_THREAD_GIL_EXIT();
MP_THREAD_GIL_ENTER();
return MP_OBJ_FROM_PTR(o);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mod_os_listdir_obj, 0, 1,
mod_os_listdir);
STATIC mp_obj_t mod_os_errno(size_t n_args, const mp_obj_t *args)
{
if (n_args == 0) {
return MP_OBJ_NEW_SMALL_INT(errno);
}
errno = mp_obj_get_int(args[0]);
return mp_const_none;
}
MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mod_os_errno_obj, 0, 1, mod_os_errno);
STATIC mp_obj_t mod_os_chdir(mp_obj_t path_in)
{
// TODO: Accept mode param
const char *path = mp_obj_str_get_str(path_in);
char abspath[256] = { 0 };
path = py_get_realpath(path, abspath, sizeof(abspath));
MP_THREAD_GIL_EXIT();
int r = chdir(path);
MP_THREAD_GIL_ENTER();
return MP_OBJ_NEW_SMALL_INT(r);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(mod_os_chdir_obj, mod_os_chdir);
STATIC mp_obj_t mod_os_getcwd()
{
// TODO: Accept mode param
char buf[MICROPY_ALLOC_PATH_MAX + 1];
const char *ret = getcwd(buf, sizeof(buf));
if (ret == NULL) {
mp_raise_OSError(errno);
}
return mp_obj_new_str(ret, strlen(ret));
}
STATIC MP_DEFINE_CONST_FUN_OBJ_0(mod_os_getcwd_obj, mod_os_getcwd);
STATIC mp_obj_t mod_os_file_open(mp_obj_t path_in, mp_obj_t mode_in)
{
const char *path = mp_obj_str_get_str(path_in);
const char *mode = mp_obj_str_get_str(mode_in);
if (path == NULL || mode == NULL) {
mp_raise_OSError(EINVAL);
return mp_const_none;
}
FILE *stream = fopen(path, mode);
if (stream == NULL) {
// mp_raise_OSError(ENOENT);
return mp_const_none;
}
return MP_OBJ_FROM_PTR(stream);
}
MP_DEFINE_CONST_FUN_OBJ_2(mod_os_file_open_obj, mod_os_file_open);
STATIC mp_obj_t mod_os_file_close(mp_obj_t stream_in)
{
FILE *stream = (FILE *)MP_OBJ_TO_PTR(stream_in);
int ret = -1;
if (stream != NULL) {
ret = fclose(stream);
} else {
ret = 0;
}
return mp_obj_new_int(ret);
}
MP_DEFINE_CONST_FUN_OBJ_1(mod_os_file_close_obj, mod_os_file_close);
STATIC mp_obj_t mod_os_file_read(size_t n_args, const mp_obj_t *args)
{
if (n_args < 4) {
mp_raise_OSError(EINVAL);
return mp_const_false;
}
mp_int_t size = mp_obj_get_int(args[1]);
mp_int_t nmemb = mp_obj_get_int(args[2]);
FILE *stream = (FILE *)MP_OBJ_TO_PTR(args[3]);
mp_buffer_info_t bufinfo;
mp_get_buffer_raise(args[0], &bufinfo, MP_BUFFER_WRITE);
int ret = -1;
if (stream != NULL) {
ret = fread(bufinfo.buf, size, nmemb, stream);
}
return mp_obj_new_int(ret);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR(mod_os_file_read_obj, 4, mod_os_file_read);
STATIC mp_obj_t mod_os_file_write(size_t n_args, const mp_obj_t *args)
{
if (n_args < 4) {
mp_raise_OSError(EINVAL);
return mp_const_false;
}
mp_int_t size = mp_obj_get_int(args[1]);
mp_int_t nmemb = mp_obj_get_int(args[2]);
FILE *stream = (FILE *)MP_OBJ_TO_PTR(args[3]);
mp_buffer_info_t bufinfo;
mp_get_buffer_raise(args[0], &bufinfo, MP_BUFFER_READ);
int ret = -1;
if (stream != NULL) {
ret = fwrite(bufinfo.buf, size, nmemb, stream);
}
return mp_obj_new_int(ret);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR(mod_os_file_write_obj, 4, mod_os_file_write);
STATIC mp_obj_t mod_os_file_seek(mp_obj_t stream_in, mp_obj_t offset_in,
mp_obj_t whence_in)
{
FILE *stream = (FILE *)MP_OBJ_TO_PTR(stream_in);
if (stream == NULL) {
mp_raise_OSError(EINVAL);
return mp_const_false;
}
mp_int_t offset = mp_obj_get_int(offset_in);
mp_int_t whence = mp_obj_get_int(whence_in);
int ret = fseek(stream, offset, whence);
return mp_obj_new_int(ret);
}
MP_DEFINE_CONST_FUN_OBJ_3(mod_os_file_seek_obj, mod_os_file_seek);
STATIC mp_obj_t mod_os_file_tell(mp_obj_t stream_in)
{
FILE *stream = (FILE *)MP_OBJ_TO_PTR(stream_in);
if (stream == NULL) {
mp_raise_OSError(EINVAL);
return mp_const_false;
}
int ret = ftell(stream);
return mp_obj_new_int(ret);
}
MP_DEFINE_CONST_FUN_OBJ_1(mod_os_file_tell_obj, mod_os_file_tell);
STATIC mp_obj_t mod_os_file_rewind(mp_obj_t stream_in)
{
FILE *stream = (FILE *)MP_OBJ_TO_PTR(stream_in);
if (stream == NULL) {
mp_raise_OSError(EINVAL);
return mp_const_false;
}
rewind(stream);
return mp_const_none;
}
MP_DEFINE_CONST_FUN_OBJ_1(mod_os_file_rewind_obj, mod_os_file_rewind);
STATIC mp_obj_t mod_os_file_getpos(mp_obj_t stream_in)
{
FILE *stream = (FILE *)MP_OBJ_TO_PTR(stream_in);
if (stream == NULL) {
mp_raise_OSError(EINVAL);
return mp_const_false;
} else {
fpos_t pos;
int ret = fgetpos(stream, &pos);
if (ret == 0) {
return mp_obj_new_int(pos);
} else {
return mp_obj_new_int(-1);
}
}
}
MP_DEFINE_CONST_FUN_OBJ_1(mod_os_file_getpos_obj, mod_os_file_getpos);
STATIC mp_obj_t mod_os_file_setpos(mp_obj_t stream_in, mp_obj_t pos_in)
{
FILE *stream = (FILE *)MP_OBJ_TO_PTR(stream_in);
if (stream == NULL) {
mp_raise_OSError(EINVAL);
return mp_const_false;
}
mp_int_t pos = mp_obj_get_int(pos_in);
int ret = fsetpos(stream, &pos);
return mp_obj_new_int(ret);
}
MP_DEFINE_CONST_FUN_OBJ_2(mod_os_file_setpos_obj, mod_os_file_setpos);
/// \function sync()
/// Sync all filesystems.
STATIC mp_obj_t os_sync(void)
{
#if MICROPY_VFS_FAT
for (mp_vfs_mount_t *vfs = MP_STATE_VM(vfs_mount_table); vfs != NULL;
vfs = vfs->next) {
// this assumes that vfs->obj is fs_user_mount_t with block device
// functions
disk_ioctl(MP_OBJ_TO_PTR(vfs->obj), CTRL_SYNC, NULL);
}
#endif
return mp_const_none;
}
MP_DEFINE_CONST_FUN_OBJ_0(mod_os_sync_obj, os_sync);
#if MICROPY_PY_OS_DUPTERM
STATIC mp_obj_t os_dupterm_notify(mp_obj_t obj_in)
{
(void)obj_in;
for (;;) {
int c = mp_uos_dupterm_rx_chr();
if (c < 0) {
break;
}
ringbuf_put(&stdin_ringbuf, c);
mp_hal_wake_main_task_from_isr();
}
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(os_dupterm_notify_obj, os_dupterm_notify);
#endif
STATIC const mp_rom_map_elem_t os_module_globals_table[] = {
{ MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_uos) },
{ MP_ROM_QSTR(MP_QSTR_uname), MP_ROM_PTR(&os_uname_obj) },
{ MP_ROM_QSTR(MP_QSTR_urandom), MP_ROM_PTR(&os_urandom_obj) },
{ MP_ROM_QSTR(MP_QSTR_version), MP_ROM_PTR(&os_version_obj) },
{ MP_ROM_QSTR(MP_QSTR_version_info), MP_ROM_PTR(&os_version_info_obj) },
#if MICROPY_PY_OS_DUPTERM
{ MP_ROM_QSTR(MP_QSTR_dupterm), MP_ROM_PTR(&mp_uos_dupterm_obj) },
{ MP_ROM_QSTR(MP_QSTR_dupterm_notify), MP_ROM_PTR(&os_dupterm_notify_obj) },
#endif
#if MICROPY_VFS
{ MP_ROM_QSTR(MP_QSTR_ilistdir), MP_ROM_PTR(&mp_vfs_ilistdir_obj) },
{ MP_ROM_QSTR(MP_QSTR_listdir), MP_ROM_PTR(&mp_vfs_listdir_obj) },
{ MP_ROM_QSTR(MP_QSTR_mkdir), MP_ROM_PTR(&mp_vfs_mkdir_obj) },
{ MP_ROM_QSTR(MP_QSTR_rmdir), MP_ROM_PTR(&mp_vfs_rmdir_obj) },
{ MP_ROM_QSTR(MP_QSTR_chdir), MP_ROM_PTR(&mp_vfs_chdir_obj) },
{ MP_ROM_QSTR(MP_QSTR_getcwd), MP_ROM_PTR(&mp_vfs_getcwd_obj) },
{ MP_ROM_QSTR(MP_QSTR_remove), MP_ROM_PTR(&mp_vfs_remove_obj) },
{ MP_ROM_QSTR(MP_QSTR_rename), MP_ROM_PTR(&mp_vfs_rename_obj) },
{ MP_ROM_QSTR(MP_QSTR_stat), MP_ROM_PTR(&mp_vfs_stat_obj) },
{ MP_ROM_QSTR(MP_QSTR_statvfs), MP_ROM_PTR(&mp_vfs_statvfs_obj) },
{ MP_ROM_QSTR(MP_QSTR_mount), MP_ROM_PTR(&mp_vfs_mount_obj) },
{ MP_ROM_QSTR(MP_QSTR_umount), MP_ROM_PTR(&mp_vfs_umount_obj) },
{ MP_ROM_QSTR(MP_QSTR_unlink),
MP_ROM_PTR(&mp_vfs_remove_obj) }, // unlink aliases to remove
#if MICROPY_VFS_POSIX
{ MP_ROM_QSTR(MP_QSTR_VfsPosix), MP_ROM_PTR(&mp_type_vfs_posix) },
#endif
#if MICROPY_VFS_FAT
{ MP_ROM_QSTR(MP_QSTR_VfsFat), MP_ROM_PTR(&mp_fat_vfs_type) },
#endif
#if MICROPY_VFS_LFS1
{ MP_ROM_QSTR(MP_QSTR_VfsLfs1), MP_ROM_PTR(&mp_type_vfs_lfs1) },
#endif
#if MICROPY_VFS_LFS2
{ MP_ROM_QSTR(MP_QSTR_VfsLfs2), MP_ROM_PTR(&mp_type_vfs_lfs2) },
#endif
#endif
{ MP_ROM_QSTR(MP_QSTR_sync), MP_ROM_PTR(&mod_os_sync_obj) },
{ MP_ROM_QSTR(MP_QSTR_sep), MP_ROM_QSTR(MP_QSTR__slash_) },
{ MP_ROM_QSTR(MP_QSTR_errno), MP_ROM_PTR(&mod_os_errno_obj) },
{ MP_ROM_QSTR(MP_QSTR_system), MP_ROM_PTR(&mod_os_system_obj) },
{ MP_ROM_QSTR(MP_QSTR_getenv), MP_ROM_PTR(&mod_os_getenv_obj) },
{ MP_ROM_QSTR(MP_QSTR_putenv), MP_ROM_PTR(&mod_os_putenv_obj) },
{ MP_ROM_QSTR(MP_QSTR_unsetenv), MP_ROM_PTR(&mod_os_unsetenv_obj) },
// file operation
{ MP_ROM_QSTR(MP_QSTR_open), MP_ROM_PTR(&mod_os_file_open_obj) },
{ MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&mod_os_file_read_obj) },
{ MP_ROM_QSTR(MP_QSTR_write), MP_ROM_PTR(&mod_os_file_write_obj) },
{ MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&mod_os_file_close_obj) },
{ MP_ROM_QSTR(MP_QSTR_seek), MP_ROM_PTR(&mod_os_file_seek_obj) },
{ MP_ROM_QSTR(MP_QSTR_tell), MP_ROM_PTR(&mod_os_file_tell_obj) },
{ MP_ROM_QSTR(MP_QSTR_rewind), MP_ROM_PTR(&mod_os_file_rewind_obj) },
{ MP_ROM_QSTR(MP_QSTR_getpos), MP_ROM_PTR(&mod_os_file_getpos_obj) },
{ MP_ROM_QSTR(MP_QSTR_setpos), MP_ROM_PTR(&mod_os_file_setpos_obj) },
};
STATIC MP_DEFINE_CONST_DICT(os_module_globals, os_module_globals_table);
const mp_obj_module_t uos_module = {
.base = { &mp_type_module },
.globals = (mp_obj_dict_t *)&os_module_globals,
};
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/moduos.c | C | apache-2.0 | 28,764 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2013, 2014 Damien P. George
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <stdio.h>
#include <string.h>
#include "extmod/utime_mphal.h"
#include "shared/timeutils/timeutils.h"
#include "py/obj.h"
#include "py/runtime.h"
#include "py/smallint.h"
#include "time.h"
#if MICROPY_PY_UTIME
STATIC mp_obj_t time_localtime(size_t n_args, const mp_obj_t *args)
{
timeutils_struct_time_t tm;
mp_int_t seconds;
if (n_args == 0 || args[0] == mp_const_none) {
struct timeval tv;
gettimeofday(&tv, NULL);
seconds = tv.tv_sec + 3600 * 8;
} else {
seconds = mp_obj_get_int(args[0]);
}
timeutils_seconds_since_epoch_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);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(time_localtime_obj, 0, 1,
time_localtime);
STATIC mp_obj_t time_mktime(mp_obj_t tuple)
{
size_t len;
mp_obj_t *elem;
mp_obj_get_array(tuple, &len, &elem);
// localtime generates a tuple of len 8. CPython uses 9, so we accept both.
if (len < 8 || len > 9) {
mp_raise_msg_varg(
&mp_type_TypeError,
MP_ERROR_TEXT("mktime needs a tuple of length 8 or 9 (%d given)"),
len);
}
return mp_obj_new_int_from_uint(
timeutils_mktime(mp_obj_get_int(elem[0]), mp_obj_get_int(elem[1]),
mp_obj_get_int(elem[2]), mp_obj_get_int(elem[3]),
mp_obj_get_int(elem[4]), mp_obj_get_int(elem[5])));
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(time_mktime_obj, time_mktime);
STATIC mp_obj_t time_time(void)
{
struct timeval tv;
gettimeofday(&tv, NULL);
return mp_obj_new_int(tv.tv_sec);
}
MP_DEFINE_CONST_FUN_OBJ_0(time_time_obj, time_time);
STATIC const mp_rom_map_elem_t time_module_globals_table[] = {
{ MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_utime) },
{ MP_ROM_QSTR(MP_QSTR_gmtime), MP_ROM_PTR(&time_localtime_obj) },
{ MP_ROM_QSTR(MP_QSTR_localtime), MP_ROM_PTR(&time_localtime_obj) },
{ MP_ROM_QSTR(MP_QSTR_mktime), MP_ROM_PTR(&time_mktime_obj) },
{ MP_ROM_QSTR(MP_QSTR_time), MP_ROM_PTR(&time_time_obj) },
{ MP_ROM_QSTR(MP_QSTR_sleep), MP_ROM_PTR(&mp_utime_sleep_obj) },
{ MP_ROM_QSTR(MP_QSTR_sleep_ms), MP_ROM_PTR(&mp_utime_sleep_ms_obj) },
{ MP_ROM_QSTR(MP_QSTR_sleep_us), MP_ROM_PTR(&mp_utime_sleep_us_obj) },
{ MP_ROM_QSTR(MP_QSTR_ticks_ms), MP_ROM_PTR(&mp_utime_ticks_ms_obj) },
{ MP_ROM_QSTR(MP_QSTR_ticks_us), MP_ROM_PTR(&mp_utime_ticks_us_obj) },
{ MP_ROM_QSTR(MP_QSTR_ticks_cpu), MP_ROM_PTR(&mp_utime_ticks_cpu_obj) },
{ MP_ROM_QSTR(MP_QSTR_ticks_add), MP_ROM_PTR(&mp_utime_ticks_add_obj) },
{ MP_ROM_QSTR(MP_QSTR_ticks_diff), MP_ROM_PTR(&mp_utime_ticks_diff_obj) },
{ MP_ROM_QSTR(MP_QSTR_time_ns), MP_ROM_PTR(&mp_utime_time_ns_obj) },
};
STATIC MP_DEFINE_CONST_DICT(time_module_globals, time_module_globals_table);
const mp_obj_module_t utime_module = {
.base = { &mp_type_module },
.globals = (mp_obj_dict_t *)&time_module_globals,
};
#endif
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/modutime.c | C | apache-2.0 | 4,639 |
// Options to control how MicroPython is built for this port,
// overriding defaults in py/mpconfig.h.
// Board-specific definitions
#include <stdint.h>
#include <stdlib.h>
#include "mpconfigboard.h"
// object representation and NLR handling
#define MICROPY_OBJ_REPR (MICROPY_OBJ_REPR_A)
#define MICROPY_NLR_SETJMP (1)
// memory allocation policies
#define MICROPY_ALLOC_PATH_MAX (256)
// emitters
#define MICROPY_PERSISTENT_CODE_LOAD (1)
#define MICROPY_EMIT_XTENSAWIN (1)
// compiler configuration
#define MICROPY_COMP_MODULE_CONST (1)
#define MICROPY_COMP_TRIPLE_TUPLE_ASSIGN (1)
// optimisations
#define MICROPY_OPT_COMPUTED_GOTO (1)
#define MICROPY_OPT_MPZ_BITWISE (1)
// Python internal features
#define MICROPY_READER_VFS (1)
#define MICROPY_READER_POSIX (1)
#define MICROPY_ENABLE_FINALISER (1)
#define MICROPY_STACK_CHECK (1)
#define MICROPY_ENABLE_EMERGENCY_EXCEPTION_BUF (1)
#define MICROPY_KBD_EXCEPTION (1)
#define MICROPY_HELPER_REPL (1)
#define MICROPY_REPL_EMACS_KEYS (1)
#define MICROPY_REPL_AUTO_INDENT (1)
#define MICROPY_LONGINT_IMPL (MICROPY_LONGINT_IMPL_MPZ)
#define MICROPY_ENABLE_SOURCE_LINE (1)
#define MICROPY_ERROR_REPORTING (MICROPY_ERROR_REPORTING_NORMAL)
#define MICROPY_WARNINGS (1)
#define MICROPY_FLOAT_IMPL (MICROPY_FLOAT_IMPL_FLOAT)
#define MICROPY_CPYTHON_COMPAT (1)
#define MICROPY_STREAMS_NON_BLOCK (1)
#define MICROPY_STREAMS_POSIX_API (1)
#define MICROPY_MODULE_BUILTIN_INIT (1)
#define MICROPY_MODULE_WEAK_LINKS (1)
#define MICROPY_MODULE_FROZEN_STR (0)
#define MICROPY_MODULE_FROZEN_MPY (1)
#define MICROPY_QSTR_EXTRA_POOL mp_qstr_frozen_const_pool
#define MICROPY_CAN_OVERRIDE_BUILTINS (1)
#define MICROPY_USE_INTERNAL_ERRNO (0)
#define MICROPY_USE_INTERNAL_PRINTF (0) // HaaS use its own printf
#define MICROPY_ENABLE_SCHEDULER (1)
#define MICROPY_SCHEDULER_DEPTH (8 * 2)
#define MICROPY_VFS (1)
#define MICROPY_VFS_POSIX (1)
#define MICROPY_VFS_POSIX_FILE (1)
#define USE_STATFS MICROPY_VFS_POSIX
#define MICROPY_ENABLE_GC (1)
#define MICROPY_GC_HEAP_SIZE (1024 * 768)
#define MICROPY_MALLOC_USES_ALLOCATED_SIZE (0)
#define MICROPY_MEM_STATS (0)
// control over Python builtins
#define MICROPY_PY_FUNCTION_ATTRS (1)
#define MICROPY_PY_DESCRIPTORS (1)
#define MICROPY_PY_DELATTR_SETATTR (1)
#define MICROPY_PY_STR_BYTES_CMP_WARN (1)
#define MICROPY_PY_BUILTINS_STR_UNICODE (1)
#define MICROPY_PY_BUILTINS_STR_CENTER (1)
#define MICROPY_PY_BUILTINS_STR_PARTITION (1)
#define MICROPY_PY_BUILTINS_STR_SPLITLINES (1)
#define MICROPY_PY_BUILTINS_BYTEARRAY (1)
#define MICROPY_PY_BUILTINS_MEMORYVIEW (1)
#define MICROPY_PY_BUILTINS_SET (1)
#define MICROPY_PY_BUILTINS_SLICE (1)
#define MICROPY_PY_BUILTINS_SLICE_ATTRS (1)
#define MICROPY_PY_BUILTINS_SLICE_INDICES (1)
#define MICROPY_PY_BUILTINS_FROZENSET (1)
#define MICROPY_PY_BUILTINS_PROPERTY (1)
#define MICROPY_PY_BUILTINS_RANGE_ATTRS (1)
#define MICROPY_PY_BUILTINS_ROUND_INT (1)
#define MICROPY_PY_ALL_SPECIAL_METHODS (1)
#define MICROPY_PY_BUILTINS_COMPILE (1)
#define MICROPY_PY_BUILTINS_ENUMERATE (1)
#define MICROPY_PY_BUILTINS_EXECFILE (1)
#define MICROPY_PY_BUILTINS_FILTER (1)
#define MICROPY_PY_BUILTINS_REVERSED (1)
#define MICROPY_PY_BUILTINS_NOTIMPLEMENTED (1)
#define MICROPY_PY_BUILTINS_INPUT (1)
#define MICROPY_PY_BUILTINS_MIN_MAX (1)
#define MICROPY_PY_BUILTINS_POW3 (1)
#define MICROPY_PY_BUILTINS_HELP (1)
#define MICROPY_PY_BUILTINS_HELP_TEXT haas_help_text
#define MICROPY_PY_BUILTINS_HELP_MODULES (1)
#define MICROPY_PY___FILE__ (1)
#define MICROPY_PY_MICROPYTHON_MEM_INFO (1)
#define MICROPY_PY_ARRAY (1)
#define MICROPY_PY_ARRAY_SLICE_ASSIGN (1)
#define MICROPY_PY_ATTRTUPLE (1)
#define MICROPY_PY_COLLECTIONS (1)
#define MICROPY_PY_COLLECTIONS_DEQUE (1)
#define MICROPY_PY_COLLECTIONS_ORDEREDDICT (1)
#define MICROPY_PY_MATH (1)
#define MICROPY_PY_MATH_SPECIAL_FUNCTIONS (1)
#define MICROPY_PY_MATH_ISCLOSE (1)
#define MICROPY_PY_CMATH (1)
#define MICROPY_PY_GC (1)
#define MICROPY_PY_IO (1)
#define MICROPY_PY_IO_IOBASE (1)
#define MICROPY_PY_IO_FILEIO (1)
#define MICROPY_PY_IO_BYTESIO (1)
#define MICROPY_PY_IO_BUFFEREDWRITER (1)
#define MICROPY_PY_STRUCT (1)
#define MICROPY_PY_SYS (1)
#define MICROPY_PY_SYS_MAXSIZE (1)
#define MICROPY_PY_SYS_MODULES (1)
#define MICROPY_PY_SYS_EXIT (1)
#define MICROPY_PY_SYS_ATEXIT (1)
#define MICROPY_PY_SYS_STDFILES (1)
#define MICROPY_PY_SYS_STDIO_BUFFER (1)
#define MICROPY_PY_UERRNO (1)
#define MICROPY_PY_USELECT (1)
#define MICROPY_PY_UTIME_MP_HAL (1)
#define MICROPY_PY_UTIME (1)
#define MICROPY_PY_THREAD (1)
#define MICROPY_PY_THREAD_GIL (1)
#define MICROPY_PY_THREAD_GIL_VM_DIVISOR (32)
#define MICROPY_DEBUG_VERBOSE (0)
// extended modules
#define MICROPY_PY_BLUETOOTH (0)
#ifndef MICROPY_PY_BLUETOOTH
#define MICROPY_PY_BLUETOOTH (1)
#define MICROPY_PY_BLUETOOTH_ENABLE_CENTRAL_MODE (1)
#define MICROPY_BLUETOOTH_NIMBLE (1)
#define MICROPY_BLUETOOTH_NIMBLE_BINDINGS_ONLY (1)
#endif
#define MICROPY_EPOCH_IS_1970 (1)
#define MICROPY_PY_UASYNCIO (1)
#define MICROPY_PY_UCTYPES (1)
#define MICROPY_PY_UZLIB (1)
#define MICROPY_PY_UJSON (1)
#define MICROPY_PY_URE (1)
#define MICROPY_PY_URE_SUB (1)
#define MICROPY_PY_UHEAPQ (1)
#define MICROPY_PY_UTIMEQ (1)
#define MICROPY_PY_UHASHLIB (1)
#define MICROPY_PY_UHASHLIB_SHA1 (1)
#define MICROPY_PY_UHASHLIB_SHA256 (1)
#define MICROPY_PY_UHASHLIB_MD5 (1)
#define MICROPY_PY_UCRYPTOLIB (1)
#define MICROPY_PY_UBINASCII (1)
#define MICROPY_PY_UBINASCII_CRC32 (1)
#define MICROPY_PY_URANDOM (1)
#define MICROPY_PY_URANDOM_EXTRA_FUNCS (1)
#define MICROPY_PY_URANDOM_SEED_INIT_FUNC (rand())
#define MICROPY_PY_OS_DUPTERM (1)
#define MICROPY_PY_MACHINE (1)
#define MICROPY_PY_MACHINE_PIN_MAKE_NEW mp_pin_make_new
#define MICROPY_PY_MACHINE_PULSE (1)
#define MICROPY_PY_MACHINE_I2C (1)
#define MICROPY_PY_MACHINE_SPI (1)
#define MICROPY_PY_MACHINE_SPI_MSB (0)
#define MICROPY_PY_MACHINE_SPI_LSB (1)
#define MICROPY_PY_MACHINE_ADC (1)
#define MICROPY_PY_MACHINE_DAC (0)
#ifndef MICROPY_HW_ENABLE_SDCARD
#define MICROPY_HW_ENABLE_SDCARD (1)
#endif
#define MICROPY_HW_SOFTSPI_MIN_DELAY (0)
#define MICROPY_HW_SOFTSPI_MAX_BAUDRATE (200 * 1000000 / 200) // roughly, ets_get_cpu_frequency()
#define MICROPY_PY_USSL (1)
#define MICROPY_SSL_MBEDTLS (1)
#define MICROPY_PY_USSL_FINALISER (1)
#define MICROPY_PY_UWEBSOCKET (1)
#define MICROPY_PY_WEBREPL (1)
#define MICROPY_PY_FRAMEBUF (1)
#define MICROPY_PY_BTREE (0) // fatal error: btree/btree.h: No such file or directory
#define MICROPY_PY_USOCKET_EVENTS (MICROPY_PY_WEBREPL)
#define MICROPY_PY_BLUETOOTH_RANDOM_ADDR (1)
#define MICROPY_PY_BLUETOOTH_DEFAULT_GAP_NAME ("HaaS")
// fatfs configuration
#define MICROPY_FATFS_ENABLE_LFN (1)
#define MICROPY_FATFS_LFN_CODE_PAGE 437 /* 1=SFN/ANSI 437=LFN/U.S.(OEM) */
#define MICROPY_FATFS_USE_LABEL (1)
#define MICROPY_FATFS_RPATH (2)
#define MICROPY_FATFS_MULTI_PARTITION (1)
#if MICROPY_VFS_POSIX
#define mp_type_fileio mp_type_vfs_posix_fileio
#define mp_type_textio mp_type_vfs_posix_textio
#elif MICROPY_VFS_FAT
#define mp_type_fileio mp_type_vfs_fat_fileio
#define mp_type_textio mp_type_vfs_fat_textio
#elif MICROPY_VFS_LFS1
#define mp_type_fileio mp_type_vfs_lfs1_fileio
#define mp_type_textio mp_type_vfs_lfs1_textio
#elif MICROPY_VFS_LFS2
#define mp_type_fileio mp_type_vfs_lfs2_fileio
#define mp_type_textio mp_type_vfs_lfs2_textio
#endif
// use vfs's functions for import stat and builtin open
#define mp_import_stat mp_vfs_import_stat
#define mp_builtin_open mp_vfs_open
#define mp_builtin_open_obj mp_vfs_open_obj
// extended modules by HaaS
#define MICROPY_PY_AOS_SPECIFIC (1)
// use this define for CTRL+Q to exit python engine
#define MICROPY_PY_AOS_QUIT (1)
#define MICROPY_ALLOC_PARSE_CHUNK_INIT (16)
#define MICROPY_ENABLE_EXTERNAL_IMPORT (1)
#define MICROPY_ENABLE_DYNAMIC_TRIADIC (0)
#if MICROPY_PY_LVGL
#ifndef MICROPY_INCLUDED_PY_MPSTATE_H
#define MICROPY_INCLUDED_PY_MPSTATE_H
#include "misc/lv_gc.h"
#undef MICROPY_INCLUDED_PY_MPSTATE_H
#else
#include "misc/lv_gc.h"
#endif
#else
#define LV_ROOTS
#endif
#define MICROPY_PORT_ROOT_POINTERS \
LV_ROOTS \
void *mp_lv_user_data; \
const char *readline_hist[8];
// type definitions for the specific machine
#define MICROPY_MAKE_POINTER_CALLABLE(p) ((void *)((mp_uint_t)(p) | 1))
#define MP_SSIZE_MAX (0x7fffffff)
// This port is intended to be 32-bit, but unfortunately, int32_t for
// different targets may be defined in different ways - either as int
// or as long. This requires different printf formatting specifiers
// to print such value. So, we avoid int32_t and use int directly.
#define UINT_FMT "%u"
#define INT_FMT "%d"
typedef int32_t mp_int_t; // must be pointer size
typedef uint32_t mp_uint_t; // must be pointer size
typedef long mp_off_t;
// ssize_t, off_t as required by POSIX-signatured functions in stream.h
#include <sys/types.h>
// board specifics
#define MICROPY_PY_SYS_PLATFORM "AliOS-Things"
#define MICROPY_PY_SYS_NODE "V3.3"
#define MP_PLAT_PRINT_STRN(str, len) mp_hal_stdout_tx_strn_cooked(str, len)
// clang-format off
// extra built in names to add to the global namespace
#define MICROPY_PORT_BUILTINS \
{ MP_OBJ_NEW_QSTR(MP_QSTR_input), (mp_obj_t)&mp_builtin_input_obj }, \
{ MP_OBJ_NEW_QSTR(MP_QSTR_open), (mp_obj_t)&mp_builtin_open_obj }, \
{ MP_OBJ_NEW_QSTR(MP_QSTR_reboot), (mp_obj_t)&machine_reset_obj },
// clang-format on
// We need to provide a declaration/definition of alloca()
#include <alloca.h>
uint32_t cpu_intrpt_save(void);
static inline uint32_t portENTER_CRITICAL_NESTED(void)
{
return cpu_intrpt_save();
}
#define portEXIT_CRITICAL_NESTED(state) \
do { \
cpu_intrpt_restore(state); \
} while (0)
#define MICROPY_BEGIN_ATOMIC_SECTION() portENTER_CRITICAL_NESTED()
#define MICROPY_END_ATOMIC_SECTION(state) portEXIT_CRITICAL_NESTED(state)
#if MICROPY_PY_USOCKET_EVENTS
#define MICROPY_PY_USOCKET_EVENTS_HANDLER extern void usocket_events_handler(void);
#else
#define MICROPY_PY_USOCKET_EVENTS_HANDLER
#endif
#if MICROPY_PY_THREAD
#define MICROPY_EVENT_POLL_HOOK \
do { \
extern void mp_handle_pending(bool); \
mp_handle_pending(true); \
MICROPY_PY_USOCKET_EVENTS_HANDLER \
MP_THREAD_GIL_EXIT(); \
MP_THREAD_GIL_ENTER(); \
} while (0);
#else
#define MICROPY_EVENT_POLL_HOOK \
do { \
extern void mp_handle_pending(bool); \
mp_handle_pending(true); \
MICROPY_PY_USOCKET_EVENTS_HANDLER \
aos_msleep(1); \
} while (0);
#define MICROPY_THREAD_YIELD()
#endif
#define MP_STATE_PORT MP_STATE_VM
#ifdef MICROPY_PY_UTIME
#define MICROPY_PY_UTIME_DEF
#define MICROPY_PY_UTIME_DEF_WEAK_LINKS
#else
#define MICROPY_PY_UTIME_DEF
#define MICROPY_PY_UTIME_DEF_WEAK_LINKS
#endif
extern const struct _mp_obj_module_t utime_module;
extern const struct _mp_obj_module_t uos_module;
extern const struct _mp_obj_module_t mp_module_usocket;
extern const struct _mp_obj_module_t mp_module_machine;
extern const struct _mp_obj_module_t mp_module_onewire;
// clang-format off
#define MICROPY_PORT_BUILTIN_MODULES \
{ MP_OBJ_NEW_QSTR(MP_QSTR_utime), (mp_obj_t)&utime_module }, \
{ MP_OBJ_NEW_QSTR(MP_QSTR_uos), (mp_obj_t)&uos_module }, \
{ MP_OBJ_NEW_QSTR(MP_QSTR_usocket), (mp_obj_t)&mp_module_usocket }, \
{ MP_OBJ_NEW_QSTR(MP_QSTR_machine), (mp_obj_t)&mp_module_machine }, \
{ MP_OBJ_NEW_QSTR(MP_QSTR__onewire), (mp_obj_t)&mp_module_onewire }, \
// clang-format on
#define MICROPY_PORT_BUILTIN_MODULE_WEAK_LINKS MICROPY_PY_UTIME_DEF_WEAK_LINKS
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/mpconfigport.h | C | apache-2.0 | 14,005 |
#include "mphalport.h"
#include <inttypes.h>
#include <unistd.h>
#include "aos/hal/uart.h"
#include "k_default_config.h"
#include "mpsalport.h"
#include "py/mpconfig.h"
#include "py/mphal.h"
#include "py/mpstate.h"
#include "py/obj.h"
#include "py/objstr.h"
#include "py/ringbuf.h"
#include "py/runtime.h"
#include "py/stream.h"
STATIC uint8_t stdin_ringbuf_array[260];
ringbuf_t stdin_ringbuf = { stdin_ringbuf_array, sizeof(stdin_ringbuf_array), 0, 0 };
static uart_dev_t uart_stdio = { 0 };
/*
* Core UART functions to implement for a port
*/
uintptr_t mp_hal_stdio_poll(uintptr_t poll_flags)
{
uintptr_t ret = 0;
if ((poll_flags & MP_STREAM_POLL_RD) && stdin_ringbuf.iget != stdin_ringbuf.iput) {
ret |= MP_STREAM_POLL_RD;
}
return ret;
}
// Receive single character, Wait until we get UART input
int mp_hal_stdin_rx_chr(void)
{
#ifndef AOS_BOARD_HAAS700
for (;;) {
int c = ringbuf_get(&stdin_ringbuf);
if (c != -1) {
return c;
}
MICROPY_EVENT_POLL_HOOK
mp_stdin_sem_take(1); // Do not wait forever as print from mpthread want to work
}
#else
uint8_t c = 0;
mp_uint_t recv_size = 0;
int ret = -1;
memset(&uart_stdio, 0, sizeof(uart_stdio));
uart_stdio.port = 0;
// try to check whether we have receive uart input
ret = hal_uart_recv_II(&uart_stdio, &c, 1, &recv_size, 200);
if (ret == 0 && recv_size == 1)
return c;
return -MP_EAGAIN;
#endif
}
// Send string of given length
void mp_hal_stdout_tx_strn(const char *str, size_t len)
{
#if MICROPY_VFS_POSIX || MICROPY_VFS_POSIX_FILE
/* COPY LOGIC FROM UNIX IMPLEMENTATION
vfs_posix_file_write will check MICROPY_PY_OS_DUPTERM MACRO and
call this API directly
*/
ssize_t ret;
MP_HAL_RETRY_SYSCALL(ret, write(STDOUT_FILENO, str, len), {});
#else
// Only release the GIL if many characters are being sent
bool release_gil = len > 20;
if (release_gil) {
MP_THREAD_GIL_EXIT();
}
memset(&uart_stdio, 0, sizeof(uart_stdio));
uart_stdio.port = 0;
aos_hal_uart_send(&uart_stdio, str, len, 5000);
if (release_gil) {
MP_THREAD_GIL_ENTER();
}
#endif
#if MICROPY_PY_OS_DUPTERM
mp_uos_dupterm_tx_strn(str, len);
#endif
}
void mp_hal_stdout_tx_str(const char *str)
{
mp_hal_stdout_tx_strn(str, strlen(str));
}
// Efficiently convert "\n" to "\r\n"
void mp_hal_stdout_tx_strn_cooked(const char *str, size_t len)
{
const char *last = str;
while (len--) {
if (*str == '\n') {
if (str > last) {
mp_hal_stdout_tx_strn(last, str - last);
}
mp_hal_stdout_tx_strn("\r\n", 2);
++str;
last = str;
} else {
++str;
}
}
if (str > last) {
mp_hal_stdout_tx_strn(last, str - last);
}
}
mp_uint_t mp_hal_ticks_us(void)
{
return krhino_ticks_to_ms(krhino_sys_tick_get()) * 1000;
}
mp_uint_t mp_hal_ticks_ms(void)
{
return krhino_ticks_to_ms(krhino_sys_tick_get());
}
uint64_t mp_hal_time_ns(void)
{
struct timeval tv;
gettimeofday(&tv, NULL);
uint64_t ns = tv.tv_sec * 1000000000ULL;
ns += (uint64_t)tv.tv_usec * 1000ULL;
return ns;
}
mp_uint_t mp_hal_ticks_cpu(void)
{
return krhino_sys_tick_get();
}
void mp_hal_delay_us(mp_uint_t us)
{
const uint32_t pend_overhead = 150;
uint64_t t0 = aos_now_ms() * 1000;
for (;;) {
uint64_t dt = aos_now_ms() * 1000 - t0;
if (dt >= us) {
return;
}
if (dt + pend_overhead < us) {
// we have enough time to service pending events
// (don't use MICROPY_EVENT_POLL_HOOK because it also yields)
mp_handle_pending(true);
}
}
}
void mp_hal_delay_ms(mp_uint_t ms)
{
uint64_t us = ms * 1000;
uint64_t dt;
uint64_t t0 = aos_now_ms() * 1000;
for (;;) {
mp_handle_pending(true);
MICROPY_PY_USOCKET_EVENTS_HANDLER
MP_THREAD_GIL_EXIT();
uint64_t t1 = aos_now_ms() * 1000;
dt = t1 - t0;
if (dt + ((unsigned int)1000 / RHINO_CONFIG_TICKS_PER_SECOND) * 1000 >= us) {
// doing a TaskDelay would take us beyond requested delay time
aos_msleep(1);
MP_THREAD_GIL_ENTER();
t1 = aos_now_ms() * 1000;
dt = t1 - t0;
break;
} else {
mp_stdin_sem_take(1);
MP_THREAD_GIL_ENTER();
}
}
if (dt < us) {
// do the remaining delay accurately
mp_hal_delay_us(us - dt);
}
}
// Wake up the main task if it is sleeping
void mp_hal_wake_main_task_from_isr(void)
{
mp_stdin_sem_give();
}
/*******************************************************************************/
// GPIO
/*******************************************************************************/
gpio_dev_t mphal_gpio_config_obj_t[PY_GPIO_NUM_MAX] = { 0 };
mp_int_t mp_hal_pin_config_set(mp_hal_pin_obj_t pin_obj, gpio_config_t cfg)
{
gpio_dev_t dev = { 0 };
dev.port = pin_obj;
dev.config = cfg;
mp_int_t ret = aos_hal_gpio_init(&dev);
if (0 != ret) {
nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, "pin index out range"));
return ret;
}
mphal_gpio_config_obj_t[pin_obj] = dev;
return ret;
}
gpio_dev_t mp_hal_gpio_dev_get(mp_hal_pin_obj_t pin_obj)
{
if (pin_obj < 0 || pin_obj > PY_GPIO_NUM_MAX) {
nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, "pin index out range"));
return;
}
return mphal_gpio_config_obj_t[pin_obj];
}
mp_int_t mp_hal_pin_high(mp_hal_pin_obj_t pin_obj)
{
gpio_dev_t dev = { 0 };
dev = mp_hal_gpio_dev_get(pin_obj);
mp_int_t ret = aos_hal_gpio_output_high(&dev);
if (0 != ret) {
nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, "mp_hal_pin_high fail"));
}
return ret;
}
mp_int_t mp_hal_pin_low(mp_hal_pin_obj_t pin_obj)
{
gpio_dev_t dev = { 0 };
dev = mp_hal_gpio_dev_get(pin_obj);
mp_int_t ret = aos_hal_gpio_output_low(&dev);
if (0 != ret) {
nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, "mp_hal_pin_low fail"));
}
return ret;
}
mp_int_t mp_hal_pin_read(mp_hal_pin_obj_t pin_obj)
{
gpio_dev_t dev = { 0 };
dev = mp_hal_gpio_dev_get(pin_obj);
mp_int_t value = -1;
mp_int_t ret = aos_hal_gpio_input_get(&dev, &value);
if (ret < 0) {
nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, "mp_hal_pin_read fail"));
return ret;
}
return value;
}
/*******************************************************************************/
// MAC address
/*******************************************************************************/
#define MP_HAL_UNIQUE_ID_ADDRESS (0xDEADBEAF)
// Generate a random locally administered MAC address (LAA)
void mp_hal_generate_laa_mac(int idx, uint8_t buf[6])
{
uint8_t *id = (uint8_t *)MP_HAL_UNIQUE_ID_ADDRESS;
buf[0] = 0x02; // LAA range
buf[1] = (id[11] << 4) | (id[10] & 0xf);
buf[2] = (id[9] << 4) | (id[8] & 0xf);
buf[3] = (id[7] << 4) | (id[6] & 0xf);
buf[4] = id[2];
buf[5] = (id[0] << 2) | idx;
}
// A board can override this if needed
MP_WEAK void mp_hal_get_mac(int idx, uint8_t buf[6])
{
mp_hal_generate_laa_mac(idx, buf);
}
void mp_hal_get_mac_ascii(int idx, size_t chr_off, size_t chr_len, char *dest)
{
static const char hexchr[16] = "0123456789ABCDEF";
uint8_t mac[6];
mp_hal_get_mac(idx, mac);
for (; chr_len; ++chr_off, --chr_len) {
*dest++ = hexchr[mac[chr_off >> 1] >> (4 * (1 - (chr_off & 1))) & 0xf];
}
}
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/mphalport.c | C | apache-2.0 | 7,668 |
#ifndef INCLUDED_MPHALPORT_H
#define INCLUDED_MPHALPORT_H
#include "shared/runtime/interrupt_char.h"
#include "py/ringbuf.h"
#include "py/mpconfig.h"
typedef mp_uint_t cpu_stack_t;
extern ringbuf_t stdin_ringbuf;
extern void mp_hal_set_interrupt_char(int c);
// This macro is used to implement PEP 475 to retry specified syscalls on EINTR
#define MP_HAL_RETRY_SYSCALL(ret, syscall, raise) \
{ \
for (;;) { \
MP_THREAD_GIL_EXIT(); \
ret = syscall; \
MP_THREAD_GIL_ENTER(); \
if (ret == -1) { \
int err = errno; \
if (err == MP_EINTR) { \
mp_handle_pending(true); \
continue; \
} \
raise; \
} \
break; \
} \
}
#define RAISE_ERRNO(err_flag, error_val) \
{ \
if (err_flag == -1) { \
mp_raise_OSError(error_val); \
} \
}
#define mp_hal_delay_us_fast(us) mp_hal_delay_us(us)
#define mp_hal_quiet_timing_enter() MICROPY_BEGIN_ATOMIC_SECTION()
#define mp_hal_quiet_timing_exit(irq_state) MICROPY_END_ATOMIC_SECTION(irq_state)
#include "aos_hal_gpio.h"
#include "py/obj.h"
#ifdef CONFIG_GPIO_NUM
#define PY_GPIO_NUM_MAX CONFIG_GPIO_NUM
#else
#define PY_GPIO_NUM_MAX 64
#endif
#define MP_HAL_PIN_FMT "%u"
#define mp_hal_pin_obj_t mp_uint_t
extern gpio_dev_t mphal_gpio_config_obj_t[PY_GPIO_NUM_MAX];
mp_hal_pin_obj_t machine_pin_get_id(mp_obj_t pin_in);
gpio_dev_t mp_hal_gpio_dev_get(mp_hal_pin_obj_t pin_obj);
mp_int_t mp_hal_pin_low(mp_hal_pin_obj_t pin_obj);
mp_int_t mp_hal_pin_high(mp_hal_pin_obj_t pin_obj);
mp_int_t mp_hal_pin_config_set(mp_hal_pin_obj_t pin_obj, gpio_config_t config);
#define mp_hal_get_pin_obj(o) machine_pin_get_id(o)
#define mp_hal_pin_name(p) (p)
#define mp_hal_pin_input(p) mp_hal_pin_config_set((p), INPUT_PULL_UP)
#define mp_hal_pin_output(p) mp_hal_pin_config_set((p), OUTPUT_PUSH_PULL)
#define mp_hal_pin_open_drain(p) mp_hal_pin_config_set((p), OUTPUT_OPEN_DRAIN_NO_PULL)
#define mp_hal_pin_od_low(p) mp_hal_pin_low(p)
#define mp_hal_pin_od_high(p) mp_hal_pin_high(p)
#define mp_hal_pin_write(p, v) ((v) ? mp_hal_pin_high(p) : mp_hal_pin_low(p))
#endif // INCLUDED_MPHALPORT_H
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/mphalport.h | C | apache-2.0 | 2,731 |
#include "mpsalport.h"
#include "aos/kernel.h"
#include "py/mperrno.h"
#include "ulog/ulog.h"
#include "k_api.h"
#define LOG_TAG "mp_sal_port"
mp_uint_t mp_sal_get_stack_size()
{
ktask_t *task = krhino_cur_task_get();
return task->stack_size;
}
void *mp_sal_get_stack_addr()
{
ktask_t *task = krhino_cur_task_get();
return (void *)(task->task_stack_base);
}
void mp_sal_task_delete(mp_task_t *id, mp_int_t *status)
{
*status = aos_task_delete(id);
}
mp_int_t mp_sal_mutex_create(mp_sal_mutex_obj_t *mutex)
{
#ifndef AOS_BOARD_HAAS700
int status = aos_mutex_create(mutex, 0);
#else
int status = aos_mutex_new((aos_mutex_t *)mutex);
#endif
return status;
}
mp_int_t mp_sal_mutex_lock(mp_sal_mutex_obj_t *mutex, mp_uint_t timeout)
{
if (mutex == NULL) {
LOGE(LOG_TAG, "mpthread mutex lock with mutex NULL !!");
return -MP_EINVAL;
}
if (timeout == 0) {
return 0;
}
int status = aos_mutex_lock(mutex, timeout);
return status;
}
mp_int_t mp_sal_mutex_unlock(mp_sal_mutex_obj_t *mutex)
{
if (mutex == NULL) {
LOGE(LOG_TAG, "mpthread mutex unlock with mutex NULL !!");
return -MP_EINVAL;
}
int status = aos_mutex_unlock(mutex);
return status;
}
void mp_sal_mutex_delete(mp_sal_mutex_obj_t *mutex)
{
aos_mutex_free(mutex);
}
/* APIs for semphone */
mp_int_t mp_sal_sem_create(mp_sal_sem_obj_t *sem)
{
int status = aos_sem_create(sem, 0, 0);
return status;
}
mp_int_t mp_sal_sem_take(mp_sal_sem_obj_t *sem, mp_uint_t timeout)
{
if (sem == NULL) {
LOGE(LOG_TAG, "mpthread sem lock with sem NULL !!");
return -MP_EINVAL;
}
if (timeout == 0) {
return 0;
}
int status = aos_sem_wait(sem, timeout);
return status;
}
mp_int_t mp_sal_sem_give(mp_sal_sem_obj_t *sem)
{
if (sem == NULL) {
LOGE(LOG_TAG, "mpthread sem unlock with sem NULL !!");
return -MP_EINVAL;
}
aos_sem_signal(sem);
return 0;
}
void mp_sal_sem_delete(mp_sal_sem_obj_t *sem)
{
aos_sem_free(sem);
}
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/mpsalport.c | C | apache-2.0 | 2,073 |
#ifndef MICROPY_INCLUDED_SAL_H
#define MICROPY_INCLUDED_SAL_H
#include <stdio.h>
#include "aos/kernel.h"
#include "py/obj.h"
#include "ulog/ulog.h"
#define MP_SAL_THREAD_MIN_STACK_SIZE (1024 * 4)
#define MP_SAL_THREAD_DEFAULT_STACK_SIZE (MP_THREAD_MIN_STACK_SIZE + 1024)
#define MP_SAL_THREAD_PRIORITY (AOS_DEFAULT_APP_PRI - 1)
#define mp_sal_mutex_obj_t aos_mutex_t
#define mp_sal_sem_obj_t aos_sem_t
#define mp_task_t aos_task_t
mp_uint_t mp_sal_get_stack_size();
void *mp_sal_get_stack_addr();
void mp_sal_task_delete(aos_task_t *id, mp_int_t *status);
mp_int_t mp_sal_mutex_create(mp_sal_mutex_obj_t *mutex);
mp_int_t mp_sal_mutex_lock(mp_sal_mutex_obj_t *mutex, mp_uint_t timeout);
mp_int_t mp_sal_mutex_unlock(mp_sal_mutex_obj_t *mutex);
void mp_sal_mutex_delete(mp_sal_mutex_obj_t *mutex);
mp_int_t mp_sal_sem_create(mp_sal_sem_obj_t *sem);
mp_int_t mp_sal_sem_take(mp_sal_sem_obj_t *sem, mp_uint_t timeout);
mp_int_t mp_sal_sem_give(mp_sal_sem_obj_t *sem);
void mp_sal_sem_delete(mp_sal_sem_obj_t *sem);
#endif
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/mpsalport.h | C | apache-2.0 | 1,094 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* Development of the code in this file was sponsored by Microbric Pty Ltd
*
* The MIT License (MIT)
*
* Copyright (c) 2016 Damien P. George
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <stdio.h>
#include "aos_hal_uart.h"
#include "mpsalport.h"
#include "py/mphal.h"
#include "py/runtime.h"
#include "ulog/ulog.h"
#define LOG_TAG "MP_UART_PORT"
STATIC uart_dev_t s_repl_uart = { 0 };
STATIC aos_task_t uart_recv_task = NULL;
STATIC mp_sal_sem_obj_t stdin_sem = NULL;
STATIC mp_int_t py_uart_rx_notify(void *buf, uint16_t size)
{
uint8_t *data = (uint8_t *)buf;
for (uint16_t index = 0; index < size; index++) {
uint8_t c = *(data++);
if (c == mp_interrupt_char) {
mp_sched_keyboard_interrupt();
} else {
ringbuf_put(&stdin_ringbuf, c);
}
}
mp_sal_sem_give(&stdin_sem);
}
STATIC void uart_recv_mainloop(void *args)
{
uart_dev_t uart = s_repl_uart;
uint8_t recv_byte[1] = { 0 };
mp_uint_t recv_size;
int ret;
while (1) {
ret = aos_hal_uart_recv_II(&uart, recv_byte, sizeof(recv_byte),
&recv_size, HAL_WAIT_FOREVER);
if (ret != 0 || recv_size == 0) {
continue;
}
py_uart_rx_notify(recv_byte, recv_size);
}
aos_task_exit(0);
}
STATIC mp_int_t uart_recv_task_init()
{
mp_int_t status = -1;
if (uart_recv_task == NULL) {
status = aos_task_new_ext(&uart_recv_task, "_uart_recv",
uart_recv_mainloop, NULL, 1024, 32);
if (status != 0) {
LOGE(LOG_TAG, "Failed to create task[_uart_recv], status=%d\n",
status);
return status;
}
} else {
status = aos_task_resume(&uart_recv_task);
}
return status;
}
STATIC mp_int_t uart_recv_task_deinit()
{
return aos_task_suspend(&uart_recv_task);
}
uart_dev_t mp_stdin_dev_get()
{
return s_repl_uart;
}
mp_int_t mp_stdin_init(uint8_t port, mp_uint_t baud_rate)
{
int ret = uart_recv_task_init();
if (ret != 0) {
LOGE(LOG_TAG, "Failed to register cb to uart recv");
return ret;
}
ret = mp_sal_sem_create(&stdin_sem);
if (ret != 0) {
LOGE(LOG_TAG, "Failed to create sem for hal stdin");
return ret;
}
return ret;
}
mp_int_t mp_stdin_deinit()
{
memset(stdin_ringbuf.buf, 0, stdin_ringbuf.size);
stdin_ringbuf.iget = 0;
stdin_ringbuf.iput = 0;
uart_recv_task_deinit();
mp_sal_sem_delete(&stdin_sem);
}
mp_int_t mp_stdin_sem_give()
{
return mp_sal_sem_give(&stdin_sem);
}
mp_int_t mp_stdin_sem_take(mp_uint_t timeout)
{
return mp_sal_sem_take(&stdin_sem, timeout);
}
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/mpstdinport.c | C | apache-2.0 | 3,837 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* Development of the code in this file was sponsored by Microbric Pty Ltd
*
* The MIT License (MIT)
*
* Copyright (c) 2016 Damien P. George
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#ifndef MICROPY_STDIN_H
#define MICROPY_STDIN_H
#include <stdio.h>
#include "aos_hal_uart.h"
#include "mpsalport.h"
#include "py/mphal.h"
#include "py/runtime.h"
#include "ulog/ulog.h"
uart_dev_t mp_stdin_dev_get();
mp_int_t mp_stdin_init(uint8_t port, mp_uint_t baud_rate);
mp_int_t mp_stdin_deinit();
mp_int_t mp_stdin_sem_give();
mp_int_t mp_stdin_sem_take(mp_uint_t timeout);
#endif
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/mpstdinport.h | C | apache-2.0 | 1,699 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2016 Damien P. George on behalf of Pycom Ltd
* Copyright (c) 2017 Pycom Limited
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include "mpthreadport.h"
#include "aos/kernel.h"
#include "mphalport.h"
#include "mpsalport.h"
#include "py/gc.h"
#include "py/mpconfig.h"
#include "py/mperrno.h"
#include "py/mpstate.h"
#include "py/mpthread.h"
#include "stdio.h"
#if MICROPY_PY_THREAD
#define LOG_TAG "MP_THREAD"
#define MP_THREAD_MIN_STACK_SIZE MP_SAL_THREAD_MIN_STACK_SIZE
#define MP_THREAD_DEFAULT_STACK_SIZE MP_SAL_THREAD_DEFAULT_STACK_SIZE
#define MP_THREAD_PRIORITY MP_SAL_THREAD_PRIORITY
// this structure forms a linked list, one node per active thread
typedef struct _thread_t {
mp_task_t id; // task id of thread
int ready; // whether the thread is ready and running
void *arg; // thread Python args, a GC root pointer
void *stack_addr; // pointer to the stack
size_t stack_len; // number of bytes in the stack
struct _thread_t *next;
} thread_t;
STATIC aos_task_key_t tls_key;
// the mutex controls access to the linked list
STATIC mp_thread_mutex_t thread_mutex;
STATIC thread_t thread_entry0;
STATIC thread_t *thread = NULL; // root pointer, handled by mp_thread_gc_others
void mp_thread_init(void *stack_addr, mp_uint_t stack_len)
{
aos_task_key_create(&tls_key);
aos_task_setspecific(tls_key, &mp_state_ctx.thread);
mp_thread_set_state(&mp_state_ctx.thread);
// create the first entry in the linked list of all threads
thread_entry0.id = aos_task_self();
thread_entry0.ready = 1;
thread_entry0.arg = NULL;
thread_entry0.stack_addr = stack_addr;
thread_entry0.stack_len = stack_len;
thread_entry0.next = NULL;
mp_thread_mutex_init(&thread_mutex);
// vPortCleanUpTCB needs the thread ready after thread_mutex is ready
thread = &thread_entry0;
}
void mp_thread_gc_others(void)
{
mp_thread_mutex_lock(&thread_mutex, 1);
for (thread_t *th = thread; th != NULL; th = th->next) {
gc_collect_root((void **)&th, 1);
gc_collect_root(&th->arg, 1);
if (th->id == aos_task_self()) {
continue;
}
if (!th->ready) {
continue;
}
gc_collect_root(th->stack_addr, th->stack_len);
}
mp_thread_mutex_unlock(&thread_mutex);
}
mp_state_thread_t *mp_thread_get_state(void)
{
mp_state_thread_t *state = (mp_state_thread_t *)aos_task_getspecific(tls_key);
if (state == NULL) {
state = &mp_state_ctx.thread;
}
return state;
}
void mp_thread_set_state(mp_state_thread_t *state)
{
aos_task_setspecific(tls_key, state);
}
void mp_thread_start(void)
{
mp_thread_mutex_lock(&thread_mutex, 1);
for (thread_t *th = thread; th != NULL; th = th->next) {
if (th->id == aos_task_self()) {
th->ready = 1;
break;
}
}
mp_thread_mutex_unlock(&thread_mutex);
}
STATIC void *(*ext_thread_entry)(void *) = NULL;
STATIC void aos_entry(void *arg)
{
if (ext_thread_entry) {
ext_thread_entry(arg);
}
aos_task_exit(0);
}
void mp_thread_create_ex(void *(*entry)(void *), void *arg, size_t *stack_size, int priority, char *name)
{
// store thread entry function into a global variable so we can access it
ext_thread_entry = entry;
if (*stack_size == 0) {
*stack_size = MP_THREAD_DEFAULT_STACK_SIZE; // default stack size
} else if (*stack_size < MP_THREAD_MIN_STACK_SIZE) {
*stack_size = MP_THREAD_MIN_STACK_SIZE; // minimum stack size
}
// Allocate linked-list node (must be outside thread_mutex lock)
thread_t *th = m_new_obj(thread_t);
if (th == NULL) {
nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, "thread_t alloc fail"));
}
mp_thread_mutex_lock(&thread_mutex, 1);
aos_task_t engine_task;
mp_int_t result = aos_task_new_ext(&th->id, name, aos_entry, arg, *stack_size, priority);
if (result != 0) {
mp_thread_mutex_unlock(&thread_mutex);
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("can't create thread"));
}
// add thread to linked list of all threads
th->ready = 0;
th->arg = arg;
th->stack_addr = mp_sal_get_stack_addr();
th->stack_len = (*stack_size) / sizeof(cpu_stack_t);
th->next = thread;
thread = th;
// adjust the stack_size to provide room to recover from hitting the limit
*stack_size -= 1024;
mp_thread_mutex_unlock(&thread_mutex);
}
void mp_thread_create(void *(*entry)(void *), void *arg, size_t *stack_size)
{
mp_thread_create_ex(entry, arg, stack_size, MP_THREAD_PRIORITY, "mp_thread");
}
void mp_thread_finish(void)
{
mp_thread_mutex_lock(&thread_mutex, 1);
for (thread_t *th = thread; th != NULL; th = th->next) {
if (th->id == aos_task_self()) {
th->ready = 0;
break;
}
}
mp_thread_mutex_unlock(&thread_mutex);
}
void mp_thread_mutex_init(mp_thread_mutex_t *mutex)
{
aos_mutex_new((aos_mutex_t *)&(mutex->k_mutex));
}
int mp_thread_mutex_lock(mp_thread_mutex_t *mutex, int wait)
{
if (mutex->k_mutex == NULL) {
LOGE(LOG_TAG, "mp_thread_mutex_lock with k_mutex NULL!!");
return MP_EINVAL;
}
int status = aos_mutex_lock(&(mutex->k_mutex), wait ? AOS_WAIT_FOREVER : 0);
return (status == 0);
}
void mp_thread_mutex_unlock(mp_thread_mutex_t *mutex)
{
if ((mutex->k_mutex) == NULL) {
LOGE(LOG_TAG, "mpthread mutex unlock error!!");
return;
}
mp_sal_mutex_unlock(&(mutex->k_mutex));
}
void mp_thread_deinit(void)
{
for (;;) {
// Find a task to delete
mp_task_t id = NULL;
mp_thread_mutex_lock(&thread_mutex, 1);
for (thread_t *th = thread; th != NULL; th = th->next) {
// Don't delete the current task
if (th->id != aos_task_self()) {
id = th->id;
break;
}
}
mp_thread_mutex_unlock(&thread_mutex);
if (id == NULL) {
// No tasks left to delete
break;
} else {
mp_int_t status = -1;
mp_sal_task_delete(id, &status);
if (status != 0) {
LOGE(LOG_TAG, "Failed to delete task[id = 0x%X]");
}
aos_task_key_delete(tls_key);
}
}
}
#else
#endif // MICROPY_PY_THREAD
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/mpthreadport.c | C | apache-2.0 | 7,579 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2016 Damien P. George on behalf of Pycom Ltd
* Copyright (c) 2017 Pycom Limited
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#ifndef MICROPY_INCLUDED_MPTHREADPORT_H
#define MICROPY_INCLUDED_MPTHREADPORT_H
#include <stdint.h>
#include "py/mpconfig.h"
typedef struct _mp_thread_mutex_t {
void *k_mutex;
} mp_thread_mutex_t;
void mp_thread_init(void *stack, mp_uint_t stack_len);
#if MICROPY_ENABLE_GC
void mp_thread_gc_others(void);
#endif
void mp_thread_deinit(void);
#endif // MICROPY_INCLUDED_MPTHREADPORT_H
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/mpthreadport.h | C | apache-2.0 | 1,681 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2014 Damien P. George
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
// qstrs specific to this port, only needed if they aren't auto-generated
// *FORMAT-OFF*
// Entries for sys.path
Q(/lib)
| YifuLiu/AliOS-Things | components/py_engine/adapter/haas/qstrdefsport.h | C | apache-2.0 | 1,349 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* Development of the code in this file was sponsored by Microbric Pty Ltd
*
* The MIT License (MIT)
*
* Copyright (c) Alibaba AIoT
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include "utility.h"
bool callback_to_python_LoBo(mp_obj_t function, mp_obj_t arg, void *carg)
{
bool ret = false;
if (function != MP_OBJ_NULL && mp_obj_is_callable(function)) {
ret = mp_sched_schedule_LoBo(function, arg, carg);
if (ret == false) {
printf("[utility]: schedule queue is full !!!!\r\n");
}
mp_hal_wake_main_task_from_isr();
}
return ret;
}
mp_obj_t mp_obj_new_strn(const char *data)
{
return mp_obj_new_str(data, strlen(data));
}
const char *get_str_from_dict(mp_obj_t dict, const char *key)
{
mp_obj_t value_obj = mp_obj_dict_get(dict, mp_obj_new_strn(key));
return (char *)mp_obj_str_get_str(value_obj);
}
int get_int_from_dict(mp_obj_t dict, const char *key)
{
mp_obj_t value_obj = mp_obj_dict_get(dict, mp_obj_new_strn(key));
return mp_obj_get_int(value_obj);
} | YifuLiu/AliOS-Things | components/py_engine/adapter/haas/utility.c | C | apache-2.0 | 2,159 |
#ifndef PY_OBJ_UTILITY_H
#define PY_OBJ_UTILITY_H
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include "py/builtin.h"
#include "py/gc.h"
#include "py/mperrno.h"
#include "py/obj.h"
#include "py/runtime.h"
#include "py/mpstate.h"
extern void mp_hal_wake_main_task_from_isr();
bool callback_to_python_LoBo(mp_obj_t function, mp_obj_t arg, void *carg);
mp_obj_t mp_obj_new_strn(const char *data);
const char *get_str_from_dict(mp_obj_t dict, const char *key);
int get_int_from_dict(mp_obj_t dict, const char *key);
#endif | YifuLiu/AliOS-Things | components/py_engine/adapter/haas/utility.h | C | apache-2.0 | 562 |
NAME := pyengine
$(NAME)_MBINS_TYPE := app
$(NAME)_VERSION := 1.0.0
$(NAME)_SUMMARY := python engine
py_build_haas700 := y
py_build_video := y
ROOTDIR := ../../../../..
AOSROOT := $(ROOTDIR)/os/kernel_alios
PYENGINEROOT := $(AOSROOT)/components/python/py_engine
# modules
AUDIO_SRC := \
modules/audio/moduvoice.c \
modules/audio/uvoiceplayer.c \
modules/audio/uvoicerecorder.c \
modules/audio/uvoicesnd.c \
modules/audio/uvoicetts.c
BLECONFIG_SRC := \
modules/ble/modble.c
DRIVER_SRC := \
modules/driver/adc.c \
modules/driver/board_mgr.c \
modules/driver/can.c \
modules/driver/crypto.c \
modules/driver/dac.c \
modules/driver/gpio.c \
modules/driver/i2c.c \
modules/driver/ir.c \
modules/driver/keypad.c \
modules/driver/location.c \
modules/driver/pwm.c \
modules/driver/py.mk \
modules/driver/rtc.c \
modules/driver/spi.c \
modules/driver/timer.c \
modules/driver/uart.c \
modules/driver/und.c \
modules/driver/wdt.c
LK_SRC := \
modules/linksdk/modlinkkit.c \
modules/linksdk/modlinksdk.c \
modules/linksdk/module_aiot_activeinfo.c \
modules/linksdk/module_aiot_device.c \
modules/linksdk/module_aiot_dynreg.c \
modules/linksdk/module_aiot_gateway.c \
modules/linksdk/module_aiot.h \
modules/linksdk/module_aiot_mqtt.c
MODBUS_SRC := \
modules/modbus/modbus.c
MQTT_SRC := \
modules/mqtt/modmqtt.c \
modules/mqtt/module_mqtt.c \
modules/mqtt/module_mqtt_client.c \
modules/mqtt/mqttclient.c
HTTP_SRC := \
modules/network/http/httpclient.c \
modules/network/http/httputility.c \
modules/network/http/modhttp.c
OSS_SRC := \
modules/oss/modoss.c
OTA_SRC := \
modules/ota/modappota.c
SNTP_SRC := \
modules/sntp/modsntp.c
UCAMERA_SRC := \
modules/ucamera/moducamera.c
ULOG_SRC := \
modules/ulog/modlog.c
KV_SRC := \
modules/kv/modkv.c
VIDEO_SRC := \
modules/video/ak_camera.c \
modules/video/ak_codec.c \
modules/video/ak_rtsp.c \
modules/video/ak_usbcam.c \
modules/video/modvideo.c \
modules/video/videocamera.c \
modules/video/videoplayer.c \
modules/video/videorecorder.c
# adapter
ADAPTER_SRC := adapter/main.c \
adapter/haas/_frozen_mpy.c adapter/haas/help.c adapter/haas/machine_hw_i2c.c \
adapter/haas/machine_pwm.c adapter/haas/machine_timer.c adapter/haas/machine_wdt.c \
adapter/haas/moddriver.c adapter/haas/modpm.c adapter/haas/moduos.c adapter/haas/mpsalport.c \
adapter/haas/fs.c adapter/haas/machine_adc.c adapter/haas/machine_hw_spi.c adapter/haas/machine_rtc.c \
adapter/haas/machine_touchpad.c adapter/haas/modbattery.c adapter/haas/modipc.c \
adapter/haas/modsocket.c adapter/haas/modutime.c adapter/haas/mpthreadport.c \
adapter/haas/gccollect.c adapter/haas/machine_dac.c adapter/haas/machine_pin.c \
adapter/haas/machine_sw_timer.c adapter/haas/machine_uart.c adapter/haas/modcharger.c \
adapter/haas/modmachine.c adapter/haas/modsysteminfo.c adapter/haas/mphalport.c adapter/haas/utility.c
ifeq ($(py_build_haas700), y)
ADAPTER_SRC += $(wildcard adapter/haas700/*.c)
endif
# engine source
ENGINE_DRIVERS_SRC := \
engine/drivers/bus/softqspi.c \
engine/drivers/bus/softspi.c
ENGINE_EXTMOD_SRC := \
engine/extmod/machine_i2c.c engine/extmod/machine_spi.c engine/extmod/modonewire.c engine/extmod/moduhashlib.c \
engine/extmod/moduselect.c engine/extmod/moduzlib.c engine/extmod/utime_mphal.c engine/extmod/vfs_fat_file.c engine/extmod/vfs_posix_file.c \
engine/extmod/machine_mem.c engine/extmod/modbluetooth.c engine/extmod/moduasyncio.c engine/extmod/moduheapq.c \
engine/extmod/modussl_axtls.c engine/extmod/modwebrepl.c engine/extmod/vfs_blockdev.c engine/extmod/vfs_lfs.c engine/extmod/vfs_reader.c \
engine/extmod/machine_pinbase.c engine/extmod/modbtree.c engine/extmod/modubinascii.c engine/extmod/modujson.c \
engine/extmod/modussl_mbedtls.c engine/extmod/mpbthci.c engine/extmod/vfs.c engine/extmod/vfs_lfsx.c engine/extmod/virtpin.c \
engine/extmod/machine_pulse.c engine/extmod/modframebuf.c engine/extmod/moducryptolib.c engine/extmod/modurandom.c \
engine/extmod/modutimeq.c engine/extmod/network_cyw43.c engine/extmod/vfs_fat.c engine/extmod/vfs_lfsx_file.c \
engine/extmod/machine_signal.c engine/extmod/modlwip.c engine/extmod/moductypes.c engine/extmod/modure.c \
engine/extmod/moduwebsocket.c engine/extmod/uos_dupterm.c engine/extmod/vfs_fat_diskio.c engine/extmod/vfs_posix.c
ENGINE_LIB_UTILS_SRC := \
engine/lib/utils/gchelper_generic.c engine/lib/utils/gchelper_native.c \
engine/lib/utils/interrupt_char.c engine/lib/utils/mpirq.c \
engine/lib/utils/printf.c engine/lib/utils/pyexec.c \
engine/lib/utils/stdout_helpers.c engine/lib/utils/sys_stdio_mphal.c
ENGINE_LIB_READLINE_SRC += \
engine/lib/mp-readline/readline.c
ENGINE_LIB_TIMEUTILS_SRC += \
engine/lib/timeutils/timeutils.c
ENGINE_LIB_NETUTILS_SRC += \
engine/lib/netutils/dhcpserver.c engine/lib/netutils/netutils.c engine/lib/netutils/trace.c
ENGINE_PY_SRC := \
engine/py/argcheck.c engine/py/builtinimport.c engine/py/emitnx86.c \
engine/py/modcmath.c engine/py/mpstate.c engine/py/objarray.c \
engine/py/objexcept.c engine/py/objmodule.c engine/py/objstr.c \
engine/py/persistentcode.c engine/py/sequence.c \
engine/py/asmarm.c engine/py/compile.c engine/py/emitnxtensa.c \
engine/py/modcollections.c engine/py/mpz.c engine/py/objattrtuple.c \
engine/py/objfilter.c engine/py/objnamedtuple.c engine/py/objstringio.c \
engine/py/profile.c engine/py/showbc.c \
engine/py/asmbase.c engine/py/emitbc.c engine/py/emitnxtensawin.c \
engine/py/modgc.c engine/py/nativeglue.c engine/py/objbool.c \
engine/py/objfloat.c engine/py/objnone.c engine/py/objstrunicode.c \
engine/py/pystack.c engine/py/smallint.c \
engine/py/asmthumb.c engine/py/emitcommon.c engine/py/formatfloat.c \
engine/py/modio.c engine/py/nlraarch64.c engine/py/objboundmeth.c \
engine/py/objfun.c engine/py/objobject.c engine/py/objtuple.c \
engine/py/qstr.c engine/py/stackctrl.c \
engine/py/asmx64.c engine/py/emitglue.c engine/py/frozenmod.c \
engine/py/modmath.c engine/py/nlr.c engine/py/obj.c \
engine/py/objgenerator.c engine/py/objpolyiter.c engine/py/objtype.c \
engine/py/reader.c engine/py/stream.c \
engine/py/asmx86.c engine/py/emitinlinethumb.c engine/py/gc.c \
engine/py/modmicropython.c engine/py/nlrpowerpc.c engine/py/objcell.c \
engine/py/objgetitemiter.c engine/py/objproperty.c engine/py/objzip.c \
engine/py/repl.c engine/py/unicode.c \
engine/py/asmxtensa.c engine/py/emitinlinextensa.c engine/py/lexer.c \
engine/py/modstruct.c engine/py/nlrsetjmp.c engine/py/objclosure.c \
engine/py/objint.c engine/py/objrange.c engine/py/opmethods.c \
engine/py/ringbuf.c engine/py/vm.c \
engine/py/bc.c engine/py/emitnarm.c engine/py/malloc.c \
engine/py/modsys.c engine/py/nlrthumb.c engine/py/objcomplex.c \
engine/py/objint_longlong.c engine/py/objreversed.c engine/py/pairheap.c \
engine/py/runtime.c engine/py/vstr.c \
engine/py/binary.c engine/py/emitnative.c engine/py/map.c \
engine/py/modthread.c engine/py/nlrx64.c engine/py/objdeque.c \
engine/py/objint_mpz.c engine/py/objset.c engine/py/parse.c \
engine/py/runtime_utils.c engine/py/warning.c \
engine/py/builtinevex.c engine/py/emitnthumb.c engine/py/modarray.c \
engine/py/moduerrno.c engine/py/nlrx86.c engine/py/objdict.c \
engine/py/objlist.c engine/py/objsingleton.c engine/py/parsenumbase.c engine/py/scheduler.c \
engine/py/builtinhelp.c engine/py/emitnx64.c engine/py/modbuiltins.c \
engine/py/mpprint.c engine/py/nlrxtensa.c engine/py/objenumerate.c \
engine/py/objmap.c engine/py/objslice.c engine/py/parsenum.c engine/py/scope.c
ENGINE_UNZIP_SRC := \
external/unzip/src/adler32.c external/unzip/src/crc32.c external/unzip/src/gzclose.c \
external/unzip/src/gzread.c external/unzip/src/infback.c external/unzip/src/inflate.c \
external/unzip/src/ioapi.c external/unzip/src/miniunz.c external/unzip/src/uncompr.c external/unzip/src/zutil.c \
external/unzip/src/compress.c external/unzip/src/deflate.c external/unzip/src/gzlib.c \
external/unzip/src/gzwrite.c external/unzip/src/inffast.c external/unzip/src/inftrees.c \
external/unzip/src/iowin32.c external/unzip/src/trees.c external/unzip/src/unzip.c
ENGINE_AMPBOOT_SRC := \
external/amp_boot/amp_boot.c external/amp_boot/amp_boot_cmd.c external/amp_boot/amp_boot_flash.c \
external/amp_boot/amp_boot_recovery.c external/amp_boot/amp_boot_uart.c external/amp_boot/amp_boot_ymodem.c
ENGINE_AMPTASK_SRC := \
external/amp_task/amp_task.c
ENGINE_AMPUTILS_SRC := \
external/amp_utils/amp_utils.c
ENGINE_APPMGR_SRC := \
external/app_mgr/app_message.c external/app_mgr/app_mgr.c external/app_mgr/app_upgrade.c
# other
NETMGR_SRC := modules/netmgr/modnetmgr.c
NETWORK_SRC := modules/network/tcp/modtcp.c \
modules/network/udp/modudp.c
MINICV_SRC := modules/minicv/base/modules/c/src/WrapperIHaasDataInput.cpp \
modules/minicv/base/modules/c/src/WrapperIHaasImageCodec.cpp \
modules/minicv/base/modules/c/src/WrapperIHaasImageProc.cpp \
modules/minicv/base/modules/c/src/WrapperIHaasML.cpp \
modules/minicv/base/modules/c/src/WrapperIHaasUI.cpp \
modules/minicv/base/modules/c/src/WrapperIHaasVideoCodec.cpp \
modules/minicv/base/modules/core/src/HaasImageUtils.cpp
ifeq ($(py_build_ai), y)
MINICV_SRC += modules/minicv/base/modules/ml/src/HaasML.cpp \
modules/minicv/base/modules/ml/src/HaasMLCloud.cpp \
modules/minicv/base/modules/ml/src/HaasMLMnn.cpp
GLOBAL_CFLAGS += -DPY_BUILD_AI=1
endif
ifeq ($(py_build_haas700), y)
NETWORK_SRC += modules/network/modnetwork.c \
modules/network/qrcode.c
GLOBAL_CFLAGS += -DPY_PLATFORM_HAAS_700=1
endif
$(NAME)_SOURCES := $(DRIVER_SRC) $(ENGINE_DRIVERS_SRC) $(ENGINE_EXTMOD_SRC) $(ENGINE_LIB_UTILS_SRC) \
$(ENGINE_LIB_READLINE_SRC) $(ENGINE_LIB_TIMEUTILS_SRC) $(ENGINE_LIB_NETUTILS_SRC) \
$(ENGINE_PY_SRC) $(ENGINE_UNZIP_SRC) $(ENGINE_AMPBOOT_SRC) $(ENGINE_AMPTASK_SRC) \
$(ENGINE_AMPUTILS_SRC) $(NETWORK_SRC) $(ADAPTER_SRC)
ifeq ($(py_build_mqtt), y)
$(NAME)_SOURCES += $(MQTT_SRC)
GLOBAL_CFLAGS += -DPY_BUILD_MQTT=1
endif
ifeq ($(py_build_netmgr), y)
$(NAME)_SOURCES += $(BLECONFIG_SRC)
GLOBAL_CFLAGS += -DPY_BUILD_NETMGR=1
endif
ifeq ($(py_build_lk), y)
$(NAME)_SOURCES += $(LK_SRC)
GLOBAL_CFLAGS += -DPY_BUILD_LINKSDK=1
endif
ifeq ($(py_build_modbus), y)
$(NAME)_SOURCES += $(MODBUS_SRC)
GLOBAL_CFLAGS += -DPY_BUILD_MODBUS=1
endif
ifeq ($(py_build_http), y)
$(NAME)_SOURCES += $(HTTP_SRC)
GLOBAL_CFLAGS += -DPY_BUILD_HTTP=1
endif
ifeq ($(py_build_oss), y)
$(NAME)_SOURCES += $(OSS_SRC)
GLOBAL_CFLAGS += -DPY_BUILD_OSS=1
endif
ifeq ($(py_build_ota), y)
$(NAME)_SOURCES += $(OTA_SRC)
GLOBAL_CFLAGS += -DPY_BUILD_OTA=1
endif
ifeq ($(MICROPY_PY_SNTP), y)
$(NAME)_SOURCES += $(SNTP_SRC)
GLOBAL_CFLAGS += -DMICROPY_PY_SNTP=1
endif
ifeq ($(MICROPY_PY_UCAMERA), y)
$(NAME)_SOURCES += $(UCAMERA_SRC)
GLOBAL_CFLAGS += -DMICROPY_PY_UCAMERA=1
endif
ifeq ($(py_build_ulog), y)
$(NAME)_SOURCES += $(ULOG_SRC)
GLOBAL_CFLAGS += -DPY_BUILD_ULOG=1
endif
ifeq ($(py_build_kv), y)
$(NAME)_SOURCES += $(KV_SRC)
GLOBAL_CFLAGS += -DPY_BUILD_KV=1
endif
ifeq ($(py_build_system), y)
$(NAME)_SOURCES += $(SYSTEM_SRC)
GLOBAL_CFLAGS += -DPY_BUILD_SYSTEM=1
endif
ifeq ($(py_build_video), y)
$(NAME)_SOURCES += $(VIDEO_SRC)
GLOBAL_CFLAGS += -DPY_BUILD_VIDEO=1
endif
ifeq ($(py_build_minicv), y)
$(NAME)_SOURCES += $(MINICV_SRC)
endif
$(NAME)_INCLUDES += \
adapter/ \
adapter/haas/ \
modules/audio/ \
modules/ble/ \
modules/driver/ \
modules/linksdk/ \
modules/minicv/ \
modules/modbus/ \
modules/mqtt/ \
modules/netmgr/ \
modules/network/ \
modules/oss/ \
modules/ota/ \
modules/sntp/ \
modules/ucamera/ \
modules/ulog/ \
modules/kv/ \
engine/ \
engine/drivers/ \
engine/extmod/ \
engine/lib/ \
external/unzip/internal/ \
external/unzip/include/ \
external/amp_boot/ \
external/amp_task/ \
external/amp_utils/ \
external/app_mgr/ \
external/common/ \
modules/minicv/base/modules/core/include/
ifeq ($(py_build_haas700), y)
$(NAME)_INCLUDES += adapter/haas700/
endif
$(NAME)_INCLUDES += \
$(ROOTDIR)/os/driver/include \
$(ROOTDIR)/apps/zbar-0.10/out/include \
$(ROOTDIR)/workspace/os/driver/include \
$(ROOTDIR)/platform/core_module/include \
$(ROOTDIR)/platform/core_module/src/include \
$(ROOTDIR)/platform/ext_module/include \
$(ROOTDIR)/os/kernel_alios/vendor/anyka/soc/include \
$(ROOTDIR)/os/kernel_alios/vendor/anyka/soc/osal \
$(ROOTDIR)/platform/ext_lib/alios/AK37D/include \
$(ROOTDIR)/platform/ext_lib/alios/AK39EV33X/include \
$(ROOTDIR)/os/kernel_alios/vendor/anyka/soc/of \
$(ROOTDIR)/os/kernel_alios/kernel/include \
$(ROOTDIR)/os/kernel_alios/kernel/include/fs \
$(ROOTDIR)/os/kernel_alios/components/utilities \
$(ROOTDIR)/os/kernel_alios/components/utilities/cjson \
$(ROOTDIR)/os/kernel_alios/components/drivers/wlan \
$(ROOTDIR)/os/kernel_alios/components/drivers/include \
$(ROOTDIR)/os/kernel_alios/components/network/lwip/include \
$(ROOTDIR)/os/kernel_alios/components/drivers/bus/usb/include \
$(ROOTDIR)/os/kernel_alios/components/network/netmgr/netdev/include \
$(ROOTDIR)/os/kernel_alios/components/drivers/bus/usb/device/class/uvc \
$(ROOTDIR)/os/kernel_alios/components/py_engine/mpy_adaptor/component/video
ifeq ($(py_build_haas700), y)
GLOBAL_CFLAGS += -DPY_BUILD_NETWORK=1
endif
| YifuLiu/AliOS-Things | components/py_engine/aos.mk | Makefile | apache-2.0 | 14,865 |
#!/bin/bash
set -e
if [ "$(uname)" == "Darwin" ]; then
os="Darwin"
elif [ "$(expr substr $(uname -s) 1 5)" == "Linux" ]; then
os="Linux"
elif ["$(expr substr $(uname -s) 1 10)"=="MINGW32_NT"];then
os="Win32"
fi
echo "os is $os"
if [[ -f $1 ]]; then
# read arguments from file, and choose those arguments we wanted
filename=$1
while read line; do
key=$(echo $line | cut -d '=' -f1)
if [ "$os" == "Darwin" ]; then
value=$(echo $line | cut -d '=' -f2-)
elif [ "$os" == "Linux" ]; then
value=$(echo $line | cut -d '=' --complement -f1)
else
value=""
fi
case "$key" in
--toolchain) toolchain=$(echo $value | sed -e 's/^"//' -e 's/"$//');;
--lib) lib=$(echo $value | sed -e 's/^"//' -e 's/"$//');;
--target) target=$(echo $value | sed -e 's/^"//' -e 's/"$//');;
--cflag) cflag=$(echo $value | sed "s/#/ /g");;
--cxxflag) cxxflag=$(echo $value | sed "s/#/ /g");;
--asmflag) asmflag=$(echo $value | sed "s/#/ /g");;
--ldflag) ldflag=$(echo $value | sed "s/#/ /g");;
--cpu) cpu=$(echo $value | sed -e 's/^"//' -e 's/"$//');;
--macro_list) macro_list=$(echo $value | sed "s/#/ /g");;
--global_inc) global_inc=$(echo $value | sed "s/#/ /g");;
--solution_dir) solution_dir=$(echo $value | sed 's/\"//g');shift;;
*) echo "discard option $line";;
esac;
done < "$filename"
else
# choose those arguments we wanted, and discard others
until [ $# -eq 0 ]
do
key=$(echo $1 | cut -d '=' -f1)
value=$(echo $1 | cut -d '=' --complement -f1)
case "$key" in
--toolchain) toolchain=$value;shift;;
--lib) lib=$value;shift;;
--target) target=$value;shift;;
--cflag) cflag=$(echo $value | sed "s/#/ /g");shift;;
--cxxflag) cxxflag=$(echo $value | sed "s/#/ /g");shift;;
--asmflag) asmflag=$(echo $value | sed "s/#/ /g");shift;;
--ldflag) ldflag=$(echo $value | sed "s/#/ /g");shift;;
--cpu) cpu=$value;shift;;
--macro_list) macro_list=$(echo $value | sed "s/#/ /g");shift;;
--global_inc) global_inc=$(echo $value | sed "s/#/ /g");shift;;
--solution_dir) solution_dir=$(echo $value | sed 's/\"//g');shift;;
*) echo "discard option $1";shift;;
esac;
done
fi
# echo "the script is $0"
# echo "current_dir is $(pwd)"
# echo "solution_dir is $solution_dir"
# echo "toolchain is $toolchain"
# echo "lib is $lib"
# echo "target is $target"
# echo "cflag is $cflag"
# echo "cxxflag is $cxxflag"
# echo "asmflag is $asmflag"
# echo "ldflag is $ldflag"
# echo "cpu is $cpu"
# echo "macro_list is $macro_list"
# echo "global_inc is $global_inc"
# =======================================================
# do our work
comp_dir=$(dirname $0)
echo "comp_dir is $comp_dir"
modules_dir=${comp_dir}/modules
# =======================================================
# Check target board
if [[ $macro_list =~ "HAAS_EDU_K1" ]]; then
TARGET_BOARD="HaaSEDUk1"
TARGET_PLATFORM="HAAS"
elif [[ $macro_list =~ "HAAS200" ]]; then
TARGET_BOARD="HaaS200"
TARGET_PLATFORM="HAAS"
elif [[ $macro_list =~ "HAAS506" ]]; then
TARGET_BOARD="HaaS506"
TARGET_PLATFORM="HAAS"
elif [[ $macro_list =~ "M5STACKCORE2" ]]; then
TARGET_BOARD="M5STACK_CORE2"
TARGET_PLATFORM="ESP32"
elif [[ $macro_list =~ "NODEMCU32C3" ]]; then
TARGET_BOARD="GENERIC_C3"
TARGET_PLATFORM="ESP32"
elif [[ $macro_list =~ "NODEMCU32S3" ]]; then
TARGET_BOARD="GENERIC_S3"
TARGET_PLATFORM="ESP32"
else
TARGET_BOARD="GENERIC"
TARGET_PLATFORM="ESP32"
fi
echo "TARGET_BOARD is $TARGET_BOARD"
echo "TARGET_PLATFORM is $TARGET_PLATFORM"
# ======= Generate config.cmake file =========
echo "# Automatically generated by call_cmake.sh, DO NOT MODIFY" > ${modules_dir}/config.cmake
# Generate MACRO Defination
macro_list_t=$(echo ${macro_list//\-D/ })
mpy_module_key="MICROPY_PY"
mpy_module_value="1"
IFS=' ' read -r -a array <<< $macro_list_t
for element in "${array[@]}"
do
if [[ $element =~ $mpy_module_key ]]; then
echo "$element"
if [[ $element =~ $mpy_module_value ]]; then
echo "set(${element%=*} TRUE)" >> ${modules_dir}/config.cmake
else
echo "set(${element%=*} FALSE)" >> ${modules_dir}/config.cmake
fi
elif [[ $element =~ "SYSINFO_SYSTEM_VERSION" ]]; then
echo "$element"
echo "list(APPEND MICROPY_DEF_MODULES_PORT ${element})" >> ${modules_dir}/config.cmake
fi
done
echo "list(APPEND MICROPY_DEF_MODULES_PORT ${TARGET_BOARD})" >> ${modules_dir}/config.cmake
echo "list(APPEND MICROPY_DEF_MODULES_PORT AOS_KERNEL_BUILD=1)" >> ${modules_dir}/config.cmake
# =======================================================
if [ $TARGET_PLATFORM = "HAAS" ]; then
# HaaS platform build
echo "Start build HAAS target"
# 0: remove libmicropython lib firstly
rm -rf ${solution_dir}/aos_sdk/lib/libmicropython.a
# 1、Generate compile option
option_array=()
cflag_t=$(echo ${cflag//})
IFS=' ' read -r -a array_cflat <<< $cflag_t
for element in "${array_cflat[@]}"
do
if ! [[ $element =~ "-D" ]]; then
option_array+=($element)
fi
done
option_array=($(awk -v RS=' ' '!a[$1]++' <<< ${option_array[@]}))
echo "set(CMAKE_C_FLAGS \"${CMAKE_C_FLAGS} ${option_array[@]}\")" >> ${modules_dir}/config.cmake
echo "set(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS} ${option_array[@]}\")" >> ${modules_dir}/config.cmake
echo "set(MICROPY_BOARD \"${TARGET_BOARD}\")" >> ${modules_dir}/config.cmake
# 2、export cross compile toolchain
export CC=${toolchain}-gcc
export CXX=${toolchain}-g++
port_dir=${comp_dir}/adapter/haas
cd ${port_dir}
mkdir -p build-${TARGET_BOARD}
cd build-${TARGET_BOARD}
cmake ..
make
# 3、copy libmicropython.a to lib
if [ ! -d "${solution_dir}/aos_sdk/lib/" ]; then
mkdir -p ${solution_dir}/aos_sdk/lib/
fi
cp -rf libmicropython.a ${solution_dir}/aos_sdk/lib/
# 4、copy driver libs to prebuild data
source $comp_dir/build_lib_copy.sh $TARGET_BOARD
elif [ $TARGET_PLATFORM = "ESP32" ]; then
# ESP32 platform build
echo "Start build ESP32 target"
# 0: remove esp libs firstly
rm -rf ${solution_dir}/esp_sdk/lib/*
# 1: prepare IDF env
${comp_dir}/../../hardware/chip/espressif_idf/build.sh ${TARGET_BOARD}
. ${comp_dir}/../../hardware/chip/espressif_idf/esp-idf/export.sh
export ADF_PATH=${comp_dir}/../../hardware/chip/espressif_adf/esp-adf
# 2：prepare fs for esp target
port_dir=${comp_dir}/adapter/esp32
rm -rf ${solution_dir}/fs
cp -rf ${port_dir}/fs ${solution_dir}/
if [ ${TARGET_BOARD} = "M5STACK_CORE2" ]; then
cp -rf ${port_dir}/m5stackcore2/* ${solution_dir}/fs/
fi
# 3: prepare fs for esp target
cd ${port_dir}
make BOARD=${TARGET_BOARD}
# 4: copy generated static libs to solutions
cd build-${TARGET_BOARD}
mkdir -p ${solution_dir}/esp_sdk/lib
mkdir -p ${solution_dir}/esp_sdk/include
find esp-idf \( -name "*.a" -o -name "*.ld" \) -exec cp '{}' ${solution_dir}/esp_sdk/lib/ \;
cp ./esp-idf/mbedtls/mbedtls/library/libmbedtls.a ${solution_dir}/esp_sdk/lib/
cp -f sdkconfig ${solution_dir}
cp -f bootloader/bootloader.bin ${solution_dir}
cp -f partition_table/partition-table.bin ${solution_dir}
cp -f config/sdkconfig.h ${solution_dir}/esp_sdk/include/
else
echo "No target build !!!!"
fi
# =======================================================
# result
echo "run external script success"
exit 0
| YifuLiu/AliOS-Things | components/py_engine/build_cmake.sh | Shell | apache-2.0 | 7,618 |
#!/bin/bash
set -e
driver_libs=("cht8305" "si7006" "sh1106" "haaseduk1" "mpu6050" "qmi8610" "ap3216c" "qmc5883" "qmc6310" "qmp6988" "spl06" "display_driver")
echo "Start to copy HaaS driver libs to prebuild folder ......"
targetBoard=$1
echo "targetBoard=${targetBoard}"
shellPath=$(cd $(dirname ${BASH_SOURCE[0]}); pwd )
hardwarePath=${shellPath}/../../hardware
hardwarePath="`cd "${hardwarePath}";pwd`"
driverSrcPath=${shellPath}/fs
driverSrcPath="`cd "${driverSrcPath}";pwd`"
if [ ${targetBoard} = "HaaS100" ]; then
driverSrcPath=${shellPath}/adapter/haas/fs/lib
driverSrcPath="`cd "${driverSrcPath}";pwd`"
libs_dst=${hardwarePath}/chip/haas1000/prebuild/data/data/lib
fs_root=${hardwarePath}/chip/haas1000/prebuild/data/
elif [ ${targetBoard} = "HaaSEDUk1" ]; then
driverSrcPath=${shellPath}/adapter/haas/fs/lib
driverSrcPath="`cd "${driverSrcPath}";pwd`"
libs_dst=${hardwarePath}/chip/haas1000/prebuild/data/data/lib
fs_root=${hardwarePath}/chip/haas1000/prebuild/data/
else
libs_dst=${hardwarePath}/chip/haas1000/prebuild/data/data/lib
fs_root=${hardwarePath}/chip/haas1000/prebuild/data/
fi
# create lib folder if not exist
if [ ! -d "${libs_dst}" ]; then
mkdir -p ${libs_dst}
else
rm -rf ${libs_dst}/*
fi
for lib in ${driver_libs[@]}
do
temp_file=${driverSrcPath}/${lib}/$lib.py
if [ ! -f "$temp_file" ]; then
echo "lib copy error !!!!"
echo "${temp_file} NOT EXIST"
else
cp -rf ${temp_file} ${libs_dst}
fi
temp_file=${driverSrcPath}/${lib}/board.json
if [ -f "$temp_file" ]; then
cp -rf ${temp_file} ${libs_dst}
fi
done
# cp boot.py and appOta.py for haas devices
cp -rf ${shellPath}/adapter/haas/fs/boot.py ${fs_root}
if [ ! -d "${fs_root}/lib" ]; then
mkdir -p ${fs_root}/lib
else
rm -rf ${fs_root}/lib/*
fi
cp -rf ${shellPath}/adapter/haas/fs/lib/appOta.py ${fs_root}/lib/appOta.py
exit 0
| YifuLiu/AliOS-Things | components/py_engine/build_lib_copy.sh | Shell | apache-2.0 | 1,938 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2017-2018 Damien P. George
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#ifndef MICROPY_INCLUDED_DRIVERS_BUS_QSPI_H
#define MICROPY_INCLUDED_DRIVERS_BUS_QSPI_H
#include "py/mphal.h"
#define MP_SPI_ADDR_IS_32B(addr) (addr & 0xff000000)
enum {
MP_QSPI_IOCTL_INIT,
MP_QSPI_IOCTL_DEINIT,
MP_QSPI_IOCTL_BUS_ACQUIRE,
MP_QSPI_IOCTL_BUS_RELEASE,
};
typedef struct _mp_qspi_proto_t {
int (*ioctl)(void *self, uint32_t cmd);
void (*write_cmd_data)(void *self, uint8_t cmd, size_t len, uint32_t data);
void (*write_cmd_addr_data)(void *self, uint8_t cmd, uint32_t addr, size_t len, const uint8_t *src);
uint32_t (*read_cmd)(void *self, uint8_t cmd, size_t len);
void (*read_cmd_qaddr_qdata)(void *self, uint8_t cmd, uint32_t addr, size_t len, uint8_t *dest);
} mp_qspi_proto_t;
typedef struct _mp_soft_qspi_obj_t {
mp_hal_pin_obj_t cs;
mp_hal_pin_obj_t clk;
mp_hal_pin_obj_t io0;
mp_hal_pin_obj_t io1;
mp_hal_pin_obj_t io2;
mp_hal_pin_obj_t io3;
} mp_soft_qspi_obj_t;
extern const mp_qspi_proto_t mp_soft_qspi_proto;
static inline uint8_t mp_spi_set_addr_buff(uint8_t *buf, uint32_t addr) {
if (MP_SPI_ADDR_IS_32B(addr)) {
buf[0] = addr >> 24;
buf[1] = addr >> 16;
buf[2] = addr >> 8;
buf[3] = addr;
return 4;
} else {
buf[0] = addr >> 16;
buf[1] = addr >> 8;
buf[2] = addr;
return 3;
}
}
#endif // MICROPY_INCLUDED_DRIVERS_BUS_QSPI_H
| YifuLiu/AliOS-Things | components/py_engine/engine/drivers/bus/qspi.h | C | apache-2.0 | 2,634 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2017-2018 Damien P. George
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include "drivers/bus/qspi.h"
#define CS_LOW(self) mp_hal_pin_write(self->cs, 0)
#define CS_HIGH(self) mp_hal_pin_write(self->cs, 1)
#ifdef MICROPY_HW_SOFTQSPI_SCK_LOW
// Use externally provided functions for SCK control and IO reading
#define SCK_LOW(self) MICROPY_HW_SOFTQSPI_SCK_LOW(self)
#define SCK_HIGH(self) MICROPY_HW_SOFTQSPI_SCK_HIGH(self)
#define NIBBLE_READ(self) MICROPY_HW_SOFTQSPI_NIBBLE_READ(self)
#else
// Use generic pin functions for SCK control and IO reading
#define SCK_LOW(self) mp_hal_pin_write(self->clk, 0)
#define SCK_HIGH(self) mp_hal_pin_write(self->clk, 1)
#define NIBBLE_READ(self) ( \
mp_hal_pin_read(self->io0) \
| (mp_hal_pin_read(self->io1) << 1) \
| (mp_hal_pin_read(self->io2) << 2) \
| (mp_hal_pin_read(self->io3) << 3))
#endif
STATIC void nibble_write(mp_soft_qspi_obj_t *self, uint8_t v) {
mp_hal_pin_write(self->io0, v & 1);
mp_hal_pin_write(self->io1, (v >> 1) & 1);
mp_hal_pin_write(self->io2, (v >> 2) & 1);
mp_hal_pin_write(self->io3, (v >> 3) & 1);
}
STATIC int mp_soft_qspi_ioctl(void *self_in, uint32_t cmd) {
mp_soft_qspi_obj_t *self = (mp_soft_qspi_obj_t*)self_in;
switch (cmd) {
case MP_QSPI_IOCTL_INIT:
mp_hal_pin_high(self->cs);
mp_hal_pin_output(self->cs);
// Configure pins
mp_hal_pin_write(self->clk, 0);
mp_hal_pin_output(self->clk);
//mp_hal_pin_write(self->clk, 1);
mp_hal_pin_output(self->io0);
mp_hal_pin_input(self->io1);
mp_hal_pin_write(self->io2, 1);
mp_hal_pin_output(self->io2);
mp_hal_pin_write(self->io3, 1);
mp_hal_pin_output(self->io3);
break;
}
return 0; // success
}
STATIC void mp_soft_qspi_transfer(mp_soft_qspi_obj_t *self, size_t len, const uint8_t *src, uint8_t *dest) {
// Will run as fast as possible, limited only by CPU speed and GPIO time
mp_hal_pin_input(self->io1);
mp_hal_pin_output(self->io0);
if (self->io3) {
mp_hal_pin_write(self->io2, 1);
mp_hal_pin_output(self->io2);
mp_hal_pin_write(self->io3, 1);
mp_hal_pin_output(self->io3);
}
if (src) {
for (size_t i = 0; i < len; ++i) {
uint8_t data_out = src[i];
uint8_t data_in = 0;
for (int j = 0; j < 8; ++j, data_out <<= 1) {
mp_hal_pin_write(self->io0, (data_out >> 7) & 1);
mp_hal_pin_write(self->clk, 1);
data_in = (data_in << 1) | mp_hal_pin_read(self->io1);
mp_hal_pin_write(self->clk, 0);
}
if (dest != NULL) {
dest[i] = data_in;
}
}
} else {
for (size_t i = 0; i < len; ++i) {
uint8_t data_in = 0;
for (int j = 0; j < 8; ++j) {
mp_hal_pin_write(self->clk, 1);
data_in = (data_in << 1) | mp_hal_pin_read(self->io1);
mp_hal_pin_write(self->clk, 0);
}
if (dest != NULL) {
dest[i] = data_in;
}
}
}
}
STATIC void mp_soft_qspi_qread(mp_soft_qspi_obj_t *self, size_t len, uint8_t *buf) {
// Make all IO lines input
mp_hal_pin_input(self->io2);
mp_hal_pin_input(self->io3);
mp_hal_pin_input(self->io0);
mp_hal_pin_input(self->io1);
// Will run as fast as possible, limited only by CPU speed and GPIO time
while (len--) {
SCK_HIGH(self);
uint8_t data_in = NIBBLE_READ(self);
SCK_LOW(self);
SCK_HIGH(self);
*buf++ = (data_in << 4) | NIBBLE_READ(self);
SCK_LOW(self);
}
}
STATIC void mp_soft_qspi_qwrite(mp_soft_qspi_obj_t *self, size_t len, const uint8_t *buf) {
// Make all IO lines output
mp_hal_pin_output(self->io2);
mp_hal_pin_output(self->io3);
mp_hal_pin_output(self->io0);
mp_hal_pin_output(self->io1);
// Will run as fast as possible, limited only by CPU speed and GPIO time
for (size_t i = 0; i < len; ++i) {
nibble_write(self, buf[i] >> 4);
SCK_HIGH(self);
SCK_LOW(self);
nibble_write(self, buf[i]);
SCK_HIGH(self);
SCK_LOW(self);
}
//mp_hal_pin_input(self->io1);
}
STATIC void mp_soft_qspi_write_cmd_data(void *self_in, uint8_t cmd, size_t len, uint32_t data) {
mp_soft_qspi_obj_t *self = (mp_soft_qspi_obj_t*)self_in;
uint32_t cmd_buf = cmd | data << 8;
CS_LOW(self);
mp_soft_qspi_transfer(self, 1 + len, (uint8_t*)&cmd_buf, NULL);
CS_HIGH(self);
}
STATIC void mp_soft_qspi_write_cmd_addr_data(void *self_in, uint8_t cmd, uint32_t addr, size_t len, const uint8_t *src) {
mp_soft_qspi_obj_t *self = (mp_soft_qspi_obj_t*)self_in;
uint8_t cmd_buf[5] = {cmd};
uint8_t addr_len = mp_spi_set_addr_buff(&cmd_buf[1], addr);
CS_LOW(self);
mp_soft_qspi_transfer(self, addr_len + 1, cmd_buf, NULL);
mp_soft_qspi_transfer(self, len, src, NULL);
CS_HIGH(self);
}
STATIC uint32_t mp_soft_qspi_read_cmd(void *self_in, uint8_t cmd, size_t len) {
mp_soft_qspi_obj_t *self = (mp_soft_qspi_obj_t*)self_in;
uint32_t cmd_buf = cmd;
CS_LOW(self);
mp_soft_qspi_transfer(self, 1 + len, (uint8_t*)&cmd_buf, (uint8_t*)&cmd_buf);
CS_HIGH(self);
return cmd_buf >> 8;
}
STATIC void mp_soft_qspi_read_cmd_qaddr_qdata(void *self_in, uint8_t cmd, uint32_t addr, size_t len, uint8_t *dest) {
mp_soft_qspi_obj_t *self = (mp_soft_qspi_obj_t*)self_in;
uint8_t cmd_buf[7] = {cmd};
uint8_t addr_len = mp_spi_set_addr_buff(&cmd_buf[1], addr);
CS_LOW(self);
mp_soft_qspi_transfer(self, 1, cmd_buf, NULL);
mp_soft_qspi_qwrite(self, addr_len + 3, &cmd_buf[1]); // 3/4 addr bytes, 1 extra byte (0), 2 dummy bytes (4 dummy cycles)
mp_soft_qspi_qread(self, len, dest);
CS_HIGH(self);
}
const mp_qspi_proto_t mp_soft_qspi_proto = {
.ioctl = mp_soft_qspi_ioctl,
.write_cmd_data = mp_soft_qspi_write_cmd_data,
.write_cmd_addr_data = mp_soft_qspi_write_cmd_addr_data,
.read_cmd = mp_soft_qspi_read_cmd,
.read_cmd_qaddr_qdata = mp_soft_qspi_read_cmd_qaddr_qdata,
};
| YifuLiu/AliOS-Things | components/py_engine/engine/drivers/bus/softqspi.c | C | apache-2.0 | 7,390 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2016-2018 Damien P. George
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include "drivers/bus/spi.h"
int mp_soft_spi_ioctl(void *self_in, uint32_t cmd) {
mp_soft_spi_obj_t *self = (mp_soft_spi_obj_t*)self_in;
switch (cmd) {
case MP_SPI_IOCTL_INIT:
mp_hal_pin_write(self->sck, self->polarity);
mp_hal_pin_output(self->sck);
mp_hal_pin_output(self->mosi);
mp_hal_pin_input(self->miso);
break;
case MP_SPI_IOCTL_DEINIT:
break;
}
return 0;
}
void mp_soft_spi_transfer(void *self_in, size_t len, const uint8_t *src, uint8_t *dest) {
mp_soft_spi_obj_t *self = (mp_soft_spi_obj_t*)self_in;
uint32_t delay_half = self->delay_half;
// only MSB transfer is implemented
// If a port defines MICROPY_HW_SOFTSPI_MIN_DELAY, and the configured
// delay_half is equal to this value, then the software SPI implementation
// will run as fast as possible, limited only by CPU speed and GPIO time.
#ifdef MICROPY_HW_SOFTSPI_MIN_DELAY
if (delay_half == MICROPY_HW_SOFTSPI_MIN_DELAY) {
for (size_t i = 0; i < len; ++i) {
uint8_t data_out = src[i];
uint8_t data_in = 0;
for (int j = 0; j < 8; ++j, data_out <<= 1) {
mp_hal_pin_write(self->mosi, (data_out >> 7) & 1);
mp_hal_pin_write(self->sck, 1 - self->polarity);
data_in = (data_in << 1) | mp_hal_pin_read(self->miso);
mp_hal_pin_write(self->sck, self->polarity);
}
if (dest != NULL) {
dest[i] = data_in;
}
}
return;
}
#endif
for (size_t i = 0; i < len; ++i) {
uint8_t data_out = src[i];
uint8_t data_in = 0;
for (int j = 0; j < 8; ++j, data_out <<= 1) {
mp_hal_pin_write(self->mosi, (data_out >> 7) & 1);
if (self->phase == 0) {
mp_hal_delay_us_fast(delay_half);
mp_hal_pin_write(self->sck, 1 - self->polarity);
} else {
mp_hal_pin_write(self->sck, 1 - self->polarity);
mp_hal_delay_us_fast(delay_half);
}
data_in = (data_in << 1) | mp_hal_pin_read(self->miso);
if (self->phase == 0) {
mp_hal_delay_us_fast(delay_half);
mp_hal_pin_write(self->sck, self->polarity);
} else {
mp_hal_pin_write(self->sck, self->polarity);
mp_hal_delay_us_fast(delay_half);
}
}
if (dest != NULL) {
dest[i] = data_in;
}
}
}
const mp_spi_proto_t mp_soft_spi_proto = {
.ioctl = mp_soft_spi_ioctl,
.transfer = mp_soft_spi_transfer,
};
| YifuLiu/AliOS-Things | components/py_engine/engine/drivers/bus/softspi.c | C | apache-2.0 | 3,929 |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2016-2018 Damien P. George
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#ifndef MICROPY_INCLUDED_DRIVERS_BUS_SPI_H
#define MICROPY_INCLUDED_DRIVERS_BUS_SPI_H
#include "py/mphal.h"
enum {
MP_SPI_IOCTL_INIT,
MP_SPI_IOCTL_DEINIT,
};
typedef struct _mp_spi_proto_t {
int (*ioctl)(void *self, uint32_t cmd);
void (*transfer)(void *self, size_t len, const uint8_t *src, uint8_t *dest);
} mp_spi_proto_t;
typedef struct _mp_soft_spi_obj_t {
uint32_t delay_half; // microsecond delay for half SCK period
uint8_t polarity;
uint8_t phase;
mp_hal_pin_obj_t sck;
mp_hal_pin_obj_t mosi;
mp_hal_pin_obj_t miso;
} mp_soft_spi_obj_t;
extern const mp_spi_proto_t mp_soft_spi_proto;
int mp_soft_spi_ioctl(void *self, uint32_t cmd);
void mp_soft_spi_transfer(void *self, size_t len, const uint8_t *src, uint8_t *dest);
#endif // MICROPY_INCLUDED_DRIVERS_BUS_SPI_H
| YifuLiu/AliOS-Things | components/py_engine/engine/drivers/bus/spi.h | C | apache-2.0 | 2,050 |
/*****************************************************************************
*
* cc3000_common.h - CC3000 Host Driver Implementation.
* Copyright (C) 2011 Texas Instruments Incorporated - http://www.ti.com/
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the
* distribution.
*
* Neither the name of Texas Instruments Incorporated nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*****************************************************************************/
#ifndef __CC3000_COMMON_H__
#define __CC3000_COMMON_H__
#include "data_types.h"
//******************************************************************************
// Include files
//******************************************************************************
#include <stdlib.h>
#include <stdint.h>
//*****************************************************************************
// Prefix exported names to avoid name clash
//*****************************************************************************
#define CC3000_EXPORT(name) cc3000_ ## name
//*****************************************************************************
//
// If building with a C++ compiler, make all of the definitions in this header
// have a C binding.
//
//*****************************************************************************
#ifdef __cplusplus
extern "C" {
#endif
extern int CC3000_EXPORT(errno);
//*****************************************************************************
// ERROR CODES
//*****************************************************************************
#define ESUCCESS 0
#define EFAIL -1
#define EERROR EFAIL
//*****************************************************************************
// COMMON DEFINES
//*****************************************************************************
#define ERROR_SOCKET_INACTIVE -57
#define WLAN_ENABLE (1)
#define WLAN_DISABLE (0)
#define MAC_ADDR_LEN (6)
#define SP_PORTION_SIZE (32)
/*Defines for minimal and maximal RX buffer size. This size includes the spi
header and hci header.
The maximal buffer size derives from:
MTU + HCI header + SPI header + sendto() agrs size
The minimum buffer size derives from:
HCI header + SPI header + max args size
This buffer is used for receiving events and data.
The packet can not be longer than MTU size and CC3000 does not support
fragmentation. Note that the same buffer is used for reception of the data
and events from CC3000. That is why the minimum is defined.
The calculation for the actual size of buffer for reception is:
Given the maximal data size MAX_DATA that is expected to be received by
application, the required buffer is:
Using recv() or recvfrom():
max(CC3000_MINIMAL_RX_SIZE, MAX_DATA + HEADERS_SIZE_DATA + fromlen
+ ucArgsize + 1)
Using gethostbyname() with minimal buffer size will limit the host name
returned to 99 bytes only.
The 1 is used for the overrun detection
Buffer size increased to 130 following the add_profile() with WEP security
which requires TX buffer size of 130 bytes:
HEADERS_SIZE_EVNT + WLAN_ADD_PROFILE_WEP_PARAM_LEN + MAX SSID LEN + 4 * MAX KEY LEN = 130
MAX SSID LEN = 32
MAX SSID LEN = 13 (with add_profile only ascii key setting is supported,
therfore maximum key size is 13)
*/
#define CC3000_MINIMAL_RX_SIZE (130 + 1)
#define CC3000_MAXIMAL_RX_SIZE (1519 + 1)
/*Defines for minimal and maximal TX buffer size.
This buffer is used for sending events and data.
The packet can not be longer than MTU size and CC3000 does not support
fragmentation. Note that the same buffer is used for transmission of the data
and commands. That is why the minimum is defined.
The calculation for the actual size of buffer for transmission is:
Given the maximal data size MAX_DATA, the required buffer is:
Using Sendto():
max(CC3000_MINIMAL_TX_SIZE, MAX_DATA + SPI_HEADER_SIZE
+ SOCKET_SENDTO_PARAMS_LEN + SIMPLE_LINK_HCI_DATA_HEADER_SIZE + 1)
Using Send():
max(CC3000_MINIMAL_TX_SIZE, MAX_DATA + SPI_HEADER_SIZE
+ HCI_CMND_SEND_ARG_LENGTH + SIMPLE_LINK_HCI_DATA_HEADER_SIZE + 1)
The 1 is used for the overrun detection */
#define CC3000_MINIMAL_TX_SIZE (130 + 1)
#define CC3000_MAXIMAL_TX_SIZE (1519 + 1)
//TX and RX buffer sizes, allow to receive and transmit maximum data at length 8.
#ifdef CC3000_TINY_DRIVER
#define TINY_CC3000_MAXIMAL_RX_SIZE 44
#define TINY_CC3000_MAXIMAL_TX_SIZE 59
#endif
/*In order to determine your preferred buffer size,
change CC3000_MAXIMAL_RX_SIZE and CC3000_MAXIMAL_TX_SIZE to a value between
the minimal and maximal specified above.
Note that the buffers are allocated by SPI.
In case you change the size of those buffers, you might need also to change
the linker file, since for example on MSP430 FRAM devices the buffers are
allocated in the FRAM section that is allocated manually and not by IDE.
*/
#ifndef CC3000_TINY_DRIVER
#define CC3000_RX_BUFFER_SIZE (CC3000_MAXIMAL_RX_SIZE)
#define CC3000_TX_BUFFER_SIZE (CC3000_MAXIMAL_TX_SIZE)
//if defined TINY DRIVER we use smaller RX and TX buffer in order to minimize RAM consumption
#else
#define CC3000_RX_BUFFER_SIZE (TINY_CC3000_MAXIMAL_RX_SIZE)
#define CC3000_TX_BUFFER_SIZE (TINY_CC3000_MAXIMAL_TX_SIZE)
#endif
//*****************************************************************************
// Compound Types
//*****************************************************************************
typedef INT32 cc3000_time_t;
typedef UINT32 clock_t;
typedef INT32 suseconds_t;
typedef struct cc3000_timeval cc3000_timeval;
struct cc3000_timeval
{
cc3000_time_t tv_sec; /* seconds */
suseconds_t tv_usec; /* microseconds */
};
typedef CHAR *(*tFWPatches)(UINT32 *usLength);
typedef CHAR *(*tDriverPatches)(UINT32 *usLength);
typedef CHAR *(*tBootLoaderPatches)(UINT32 *usLength);
typedef void (*tWlanCB)(INT32 event_type, CHAR * data, UINT8 length );
typedef INT32 (*tWlanReadInteruptPin)(void);
typedef void (*tWlanInterruptEnable)(void);
typedef void (*tWlanInterruptDisable)(void);
typedef void (*tWriteWlanPin)(UINT8 val);
typedef struct
{
UINT16 usRxEventOpcode;
UINT16 usEventOrDataReceived;
UINT8 *pucReceivedData;
UINT8 *pucTxCommandBuffer;
tFWPatches sFWPatches;
tDriverPatches sDriverPatches;
tBootLoaderPatches sBootLoaderPatches;
tWlanCB sWlanCB;
tWlanReadInteruptPin ReadWlanInterruptPin;
tWlanInterruptEnable WlanInterruptEnable;
tWlanInterruptDisable WlanInterruptDisable;
tWriteWlanPin WriteWlanPin;
INT32 slTransmitDataError;
UINT16 usNumberOfFreeBuffers;
UINT16 usSlBufferLength;
UINT16 usBufferSize;
UINT16 usRxDataPending;
UINT32 NumberOfSentPackets;
UINT32 NumberOfReleasedPackets;
UINT8 InformHostOnTxComplete;
}sSimplLinkInformation;
extern volatile sSimplLinkInformation tSLInformation;
//*****************************************************************************
// Prototypes for the APIs.
//*****************************************************************************
//*****************************************************************************
//
//! SimpleLinkWaitEvent
//!
//! @param usOpcode command operation code
//! @param pRetParams command return parameters
//!
//! @return none
//!
//! @brief Wait for event, pass it to the hci_event_handler and
//! update the event opcode in a global variable.
//
//*****************************************************************************
extern void SimpleLinkWaitEvent(UINT16 usOpcode, void *pRetParams);
//*****************************************************************************
//
//! SimpleLinkWaitData
//!
//! @param pBuf data buffer
//! @param from from information
//! @param fromlen from information length
//!
//! @return none
//!
//! @brief Wait for data, pass it to the hci_event_handler
//! and update in a global variable that there is
//! data to read.
//
//*****************************************************************************
extern void SimpleLinkWaitData(UINT8 *pBuf, UINT8 *from, UINT8 *fromlen);
//*****************************************************************************
//
//! UINT32_TO_STREAM_f
//!
//! \param p pointer to the new stream
//! \param u32 pointer to the 32 bit
//!
//! \return pointer to the new stream
//!
//! \brief This function is used for copying 32 bit to stream
//! while converting to little endian format.
//
//*****************************************************************************
extern UINT8* UINT32_TO_STREAM_f (UINT8 *p, UINT32 u32);
//*****************************************************************************
//
//! UINT16_TO_STREAM_f
//!
//! \param p pointer to the new stream
//! \param u32 pointer to the 16 bit
//!
//! \return pointer to the new stream
//!
//! \brief This function is used for copying 16 bit to stream
//! while converting to little endian format.
//
//*****************************************************************************
extern UINT8* UINT16_TO_STREAM_f (UINT8 *p, UINT16 u16);
//*****************************************************************************
//
//! STREAM_TO_UINT16_f
//!
//! \param p pointer to the stream
//! \param offset offset in the stream
//!
//! \return pointer to the new 16 bit
//!
//! \brief This function is used for copying received stream to
//! 16 bit in little endian format.
//
//*****************************************************************************
extern UINT16 STREAM_TO_UINT16_f(CHAR* p, UINT16 offset);
//*****************************************************************************
//
//! STREAM_TO_UINT32_f
//!
//! \param p pointer to the stream
//! \param offset offset in the stream
//!
//! \return pointer to the new 32 bit
//!
//! \brief This function is used for copying received stream to
//! 32 bit in little endian format.
//
//*****************************************************************************
extern UINT32 STREAM_TO_UINT32_f(CHAR* p, UINT16 offset);
//*****************************************************************************
// COMMON MACROs
//*****************************************************************************
//This macro is used for copying 8 bit to stream while converting to little endian format.
#define UINT8_TO_STREAM(_p, _val) {*(_p)++ = (_val);}
//This macro is used for copying 16 bit to stream while converting to little endian format.
#define UINT16_TO_STREAM(_p, _u16) (UINT16_TO_STREAM_f(_p, _u16))
//This macro is used for copying 32 bit to stream while converting to little endian format.
#define UINT32_TO_STREAM(_p, _u32) (UINT32_TO_STREAM_f(_p, _u32))
//This macro is used for copying a specified value length bits (l) to stream while converting to little endian format.
#define ARRAY_TO_STREAM(p, a, l) {register INT16 _i; for (_i = 0; _i < l; _i++) *(p)++ = ((UINT8 *) a)[_i];}
//This macro is used for copying received stream to 8 bit in little endian format.
#define STREAM_TO_UINT8(_p, _offset, _u8) {_u8 = (UINT8)(*(_p + _offset));}
//This macro is used for copying received stream to 16 bit in little endian format.
#define STREAM_TO_UINT16(_p, _offset, _u16) {_u16 = STREAM_TO_UINT16_f(_p, _offset);}
//This macro is used for copying received stream to 32 bit in little endian format.
#define STREAM_TO_UINT32(_p, _offset, _u32) {_u32 = STREAM_TO_UINT32_f(_p, _offset);}
#define STREAM_TO_STREAM(p, a, l) {register INT16 _i; for (_i = 0; _i < l; _i++) *(a)++= ((UINT8 *) p)[_i];}
//*****************************************************************************
//
// Mark the end of the C bindings section for C++ compilers.
//
//*****************************************************************************
#ifdef __cplusplus
}
#endif // __cplusplus
#endif // __CC3000_COMMON_H__
| YifuLiu/AliOS-Things | components/py_engine/engine/drivers/cc3000/inc/cc3000_common.h | C | apache-2.0 | 13,674 |
/*****************************************************************************
*
* spi.h - CC3000 Host Driver Implementation.
* Copyright (C) 2011 Texas Instruments Incorporated - http://www.ti.com/
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the
* distribution.
*
* Neither the name of Texas Instruments Incorporated nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*****************************************************************************/
#ifndef __CC3000_SPI_H__
#define __CC3000_SPI_H__
//*****************************************************************************
//
// If building with a C++ compiler, make all of the definitions in this header
// have a C binding.
//
//*****************************************************************************
#ifdef __cplusplus
extern "C" {
#endif
typedef void (*gcSpiHandleRx)(void *p);
typedef void (*gcSpiHandleTx)(void);
extern unsigned char wlan_tx_buffer[];
//*****************************************************************************
//
// Prototypes for the APIs.
//
//*****************************************************************************
// the arguments must be of type pin_obj_t* and SPI_HandleTypeDef*
extern void SpiInit(void *spi, const void *pin_cs, const void *pin_en, const void *pin_irq);
extern void SpiOpen(gcSpiHandleRx pfRxHandler);
extern void SpiClose(void);
extern void SpiPauseSpi(void);
extern void SpiResumeSpi(void);
extern long SpiWrite(unsigned char *pUserBuffer, unsigned short usLength);
extern void SpiConfigureHwMapping(void);
extern void SpiCleanGPIOISR(void);
extern void SSIConfigure(unsigned long ulSSIFreq, unsigned long bForceGpioConfiguration, unsigned long uiReconfigureSysClock);
extern int init_spi(void);
extern long ReadWlanInterruptPin(void);
extern void WriteWlanPin(unsigned char val);
//*****************************************************************************
//
// Mark the end of the C bindings section for C++ compilers.
//
//*****************************************************************************
#ifdef __cplusplus
}
#endif // __cplusplus
#endif
| YifuLiu/AliOS-Things | components/py_engine/engine/drivers/cc3000/inc/ccspi.h | C | apache-2.0 | 3,456 |
/*****************************************************************************
*
* data_types.h - CC3000 Host Driver Implementation.
* Copyright (C) 2011 Texas Instruments Incorporated - http://www.ti.com/
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the
* distribution.
*
* Neither the name of Texas Instruments Incorporated nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*****************************************************************************/
#ifndef __CC3000_DATA_TYPES__
#define __CC3000_DATA_TYPES__
//*****************************************************************************
//
// If building with a C++ compiler, make all of the definitions in this header
// have a C binding.
//
//*****************************************************************************
#ifdef __cplusplus
extern "C" {
#endif
#ifndef NULL
#define NULL (0)
#endif
#ifndef FALSE
#define FALSE (0)
#endif
#ifndef TRUE
#define TRUE (!FALSE)
#endif
#ifndef OK
#define OK (0)
#endif
#ifndef _INT8
#define _INT8
typedef signed char INT8;
#endif
#ifndef _UINT8
#define _UINT8
typedef unsigned char UINT8;
#endif
#ifndef _INT16
#define _INT16
typedef signed short INT16;
#endif
#ifndef _UINT16
#define _UINT16
typedef unsigned short UINT16;
#endif
#ifndef _BOOLEAN
#define _BOOLEAN
typedef unsigned char BOOLEAN;
#endif
#ifndef _INT32
#define _INT32
typedef signed long INT32;
#endif
#ifndef _UINT32
#define _UINT32
typedef unsigned long UINT32;
#endif
typedef int INT;
typedef char CHAR;
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* __CC3000_DATA_TYPES__ */
| YifuLiu/AliOS-Things | components/py_engine/engine/drivers/cc3000/inc/data_types.h | C | apache-2.0 | 3,022 |
/*****************************************************************************
*
* evnt_handler.h - CC3000 Host Driver Implementation.
* Copyright (C) 2011 Texas Instruments Incorporated - http://www.ti.com/
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the
* distribution.
*
* Neither the name of Texas Instruments Incorporated nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*****************************************************************************/
#ifndef __CC3000_EVENT_HANDLER_H__
#define __CC3000_EVENT_HANDLER_H__
#include "hci.h"
#include "socket.h"
//*****************************************************************************
//
// If building with a C++ compiler, make all of the definitions in this header
// have a C binding.
//
//*****************************************************************************
#ifdef __cplusplus
extern "C" {
#endif
//*****************************************************************************
//
// Prototypes for the APIs.
//
//*****************************************************************************
//*****************************************************************************
//
//! hci_event_handler
//!
//! @param pRetParams incoming data buffer
//! @param from from information (in case of data received)
//! @param fromlen from information length (in case of data received)
//!
//! @return none
//!
//! @brief Parse the incoming events packets and issues corresponding
//! event handler from global array of handlers pointers
//
//*****************************************************************************
extern UINT8 *hci_event_handler(void *pRetParams, UINT8 *from, UINT8 *fromlen);
//*****************************************************************************
//
//! hci_unsol_event_handler
//!
//! @param event_hdr event header
//!
//! @return 1 if event supported and handled
//! 0 if event is not supported
//!
//! @brief Handle unsolicited events
//
//*****************************************************************************
extern INT32 hci_unsol_event_handler(CHAR *event_hdr);
//*****************************************************************************
//
//! hci_unsolicited_event_handler
//!
//! @param None
//!
//! @return ESUCCESS if successful, EFAIL if an error occurred
//!
//! @brief Parse the incoming unsolicited event packets and issues
//! corresponding event handler.
//
//*****************************************************************************
extern INT32 hci_unsolicited_event_handler(void);
#define M_BSD_RESP_PARAMS_OFFSET(hci_event_hdr)((CHAR *)(hci_event_hdr) + HCI_EVENT_HEADER_SIZE)
#define SOCKET_STATUS_ACTIVE 0
#define SOCKET_STATUS_INACTIVE 1
/* Init socket_active_status = 'all ones': init all sockets with SOCKET_STATUS_INACTIVE.
Will be changed by 'set_socket_active_status' upon 'connect' and 'accept' calls */
#define SOCKET_STATUS_INIT_VAL 0xFFFF
#define M_IS_VALID_SD(sd) ((0 <= (sd)) && ((sd) <= 7))
#define M_IS_VALID_STATUS(status) (((status) == SOCKET_STATUS_ACTIVE)||((status) == SOCKET_STATUS_INACTIVE))
extern UINT32 socket_active_status;
extern void set_socket_active_status(INT32 Sd, INT32 Status);
extern INT32 get_socket_active_status(INT32 Sd);
typedef struct _bsd_accept_return_t
{
INT32 iSocketDescriptor;
INT32 iStatus;
sockaddr tSocketAddress;
} tBsdReturnParams;
typedef struct _bsd_read_return_t
{
INT32 iSocketDescriptor;
INT32 iNumberOfBytes;
UINT32 uiFlags;
} tBsdReadReturnParams;
#define BSD_RECV_FROM_FROMLEN_OFFSET (4)
#define BSD_RECV_FROM_FROM_OFFSET (16)
typedef struct _bsd_select_return_t
{
INT32 iStatus;
UINT32 uiRdfd;
UINT32 uiWrfd;
UINT32 uiExfd;
} tBsdSelectRecvParams;
typedef struct _bsd_getsockopt_return_t
{
UINT8 ucOptValue[4];
CHAR iStatus;
} tBsdGetSockOptReturnParams;
typedef struct _bsd_gethostbyname_return_t
{
INT32 retVal;
INT32 outputAddress;
} tBsdGethostbynameParams;
//*****************************************************************************
//
// Mark the end of the C bindings section for C++ compilers.
//
//*****************************************************************************
#ifdef __cplusplus
}
#endif // __cplusplus
#endif // __CC3000_EVENT_HANDLER_H__
| YifuLiu/AliOS-Things | components/py_engine/engine/drivers/cc3000/inc/evnt_handler.h | C | apache-2.0 | 5,864 |
/*****************************************************************************
*
* hci.h - CC3000 Host Driver Implementation.
* Copyright (C) 2011 Texas Instruments Incorporated - http://www.ti.com/
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the
* distribution.
*
* Neither the name of Texas Instruments Incorporated nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*****************************************************************************/
#ifndef __CC3000_HCI_H__
#define __CC3000_HCI_H__
#include "cc3000_common.h"
//*****************************************************************************
//
// If building with a C++ compiler, make all of the definitions in this header
// have a C binding.
//
//*****************************************************************************
#ifdef __cplusplus
extern "C" {
#endif
#define SPI_HEADER_SIZE (5)
#define SIMPLE_LINK_HCI_CMND_HEADER_SIZE (4)
#define HEADERS_SIZE_CMD (SPI_HEADER_SIZE + SIMPLE_LINK_HCI_CMND_HEADER_SIZE)
#define SIMPLE_LINK_HCI_DATA_CMND_HEADER_SIZE (5)
#define SIMPLE_LINK_HCI_DATA_HEADER_SIZE (5)
#define SIMPLE_LINK_HCI_PATCH_HEADER_SIZE (2)
//*****************************************************************************
//
// Values that can be used as HCI Commands and HCI Packet header defines
//
//*****************************************************************************
#define HCI_TYPE_CMND 0x1
#define HCI_TYPE_DATA 0x2
#define HCI_TYPE_PATCH 0x3
#define HCI_TYPE_EVNT 0x4
#define HCI_EVENT_PATCHES_DRV_REQ (1)
#define HCI_EVENT_PATCHES_FW_REQ (2)
#define HCI_EVENT_PATCHES_BOOTLOAD_REQ (3)
#define HCI_CMND_WLAN_BASE (0x0000)
#define HCI_CMND_WLAN_CONNECT 0x0001
#define HCI_CMND_WLAN_DISCONNECT 0x0002
#define HCI_CMND_WLAN_IOCTL_SET_SCANPARAM 0x0003
#define HCI_CMND_WLAN_IOCTL_SET_CONNECTION_POLICY 0x0004
#define HCI_CMND_WLAN_IOCTL_ADD_PROFILE 0x0005
#define HCI_CMND_WLAN_IOCTL_DEL_PROFILE 0x0006
#define HCI_CMND_WLAN_IOCTL_GET_SCAN_RESULTS 0x0007
#define HCI_CMND_EVENT_MASK 0x0008
#define HCI_CMND_WLAN_IOCTL_STATUSGET 0x0009
#define HCI_CMND_WLAN_IOCTL_SIMPLE_CONFIG_START 0x000A
#define HCI_CMND_WLAN_IOCTL_SIMPLE_CONFIG_STOP 0x000B
#define HCI_CMND_WLAN_IOCTL_SIMPLE_CONFIG_SET_PREFIX 0x000C
#define HCI_CMND_WLAN_CONFIGURE_PATCH 0x000D
#define HCI_CMND_SOCKET_BASE 0x1000
#define HCI_CMND_SOCKET 0x1001
#define HCI_CMND_BIND 0x1002
#define HCI_CMND_RECV 0x1004
#define HCI_CMND_ACCEPT 0x1005
#define HCI_CMND_LISTEN 0x1006
#define HCI_CMND_CONNECT 0x1007
#define HCI_CMND_BSD_SELECT 0x1008
#define HCI_CMND_SETSOCKOPT 0x1009
#define HCI_CMND_GETSOCKOPT 0x100A
#define HCI_CMND_CLOSE_SOCKET 0x100B
#define HCI_CMND_RECVFROM 0x100D
#define HCI_CMND_GETHOSTNAME 0x1010
#define HCI_CMND_MDNS_ADVERTISE 0x1011
#define HCI_CMND_GETMSSVALUE 0x1012
#define HCI_DATA_BASE 0x80
#define HCI_CMND_SEND (0x01 + HCI_DATA_BASE)
#define HCI_CMND_SENDTO (0x03 + HCI_DATA_BASE)
#define HCI_DATA_BSD_RECVFROM (0x04 + HCI_DATA_BASE)
#define HCI_DATA_BSD_RECV (0x05 + HCI_DATA_BASE)
#define HCI_CMND_NVMEM_CBASE (0x0200)
#define HCI_CMND_NVMEM_CREATE_ENTRY (0x0203)
#define HCI_CMND_NVMEM_SWAP_ENTRY (0x0205)
#define HCI_CMND_NVMEM_READ (0x0201)
#define HCI_CMND_NVMEM_WRITE (0x0090)
#define HCI_CMND_NVMEM_WRITE_PATCH (0x0204)
#define HCI_CMND_READ_SP_VERSION (0x0207)
#define HCI_CMND_READ_BUFFER_SIZE 0x400B
#define HCI_CMND_SIMPLE_LINK_START 0x4000
#define HCI_CMND_NETAPP_BASE 0x2000
#define HCI_NETAPP_DHCP (0x0001 + HCI_CMND_NETAPP_BASE)
#define HCI_NETAPP_PING_SEND (0x0002 + HCI_CMND_NETAPP_BASE)
#define HCI_NETAPP_PING_REPORT (0x0003 + HCI_CMND_NETAPP_BASE)
#define HCI_NETAPP_PING_STOP (0x0004 + HCI_CMND_NETAPP_BASE)
#define HCI_NETAPP_IPCONFIG (0x0005 + HCI_CMND_NETAPP_BASE)
#define HCI_NETAPP_ARP_FLUSH (0x0006 + HCI_CMND_NETAPP_BASE)
#define HCI_NETAPP_SET_DEBUG_LEVEL (0x0008 + HCI_CMND_NETAPP_BASE)
#define HCI_NETAPP_SET_TIMERS (0x0009 + HCI_CMND_NETAPP_BASE)
//*****************************************************************************
//
// Values that can be used as HCI Events defines
//
//*****************************************************************************
#define HCI_EVNT_WLAN_BASE 0x0000
#define HCI_EVNT_WLAN_CONNECT 0x0001
#define HCI_EVNT_WLAN_DISCONNECT \
0x0002
#define HCI_EVNT_WLAN_IOCTL_ADD_PROFILE \
0x0005
#define HCI_EVNT_SOCKET HCI_CMND_SOCKET
#define HCI_EVNT_BIND HCI_CMND_BIND
#define HCI_EVNT_RECV HCI_CMND_RECV
#define HCI_EVNT_ACCEPT HCI_CMND_ACCEPT
#define HCI_EVNT_LISTEN HCI_CMND_LISTEN
#define HCI_EVNT_CONNECT HCI_CMND_CONNECT
#define HCI_EVNT_SELECT HCI_CMND_BSD_SELECT
#define HCI_EVNT_CLOSE_SOCKET HCI_CMND_CLOSE_SOCKET
#define HCI_EVNT_RECVFROM HCI_CMND_RECVFROM
#define HCI_EVNT_SETSOCKOPT HCI_CMND_SETSOCKOPT
#define HCI_EVNT_GETSOCKOPT HCI_CMND_GETSOCKOPT
#define HCI_EVNT_BSD_GETHOSTBYNAME HCI_CMND_GETHOSTNAME
#define HCI_EVNT_MDNS_ADVERTISE HCI_CMND_MDNS_ADVERTISE
#define HCI_EVNT_GETMSSVALUE HCI_CMND_GETMSSVALUE
#define HCI_EVNT_SEND 0x1003
#define HCI_EVNT_WRITE 0x100E
#define HCI_EVNT_SENDTO 0x100F
#define HCI_EVNT_PATCHES_REQ 0x1000
#define HCI_EVNT_UNSOL_BASE 0x4000
#define HCI_EVNT_WLAN_UNSOL_BASE (0x8000)
#define HCI_EVNT_WLAN_UNSOL_CONNECT (0x0001 + HCI_EVNT_WLAN_UNSOL_BASE)
#define HCI_EVNT_WLAN_UNSOL_DISCONNECT (0x0002 + HCI_EVNT_WLAN_UNSOL_BASE)
#define HCI_EVNT_WLAN_UNSOL_INIT (0x0004 + HCI_EVNT_WLAN_UNSOL_BASE)
#define HCI_EVNT_WLAN_TX_COMPLETE (0x0008 + HCI_EVNT_WLAN_UNSOL_BASE)
#define HCI_EVNT_WLAN_UNSOL_DHCP (0x0010 + HCI_EVNT_WLAN_UNSOL_BASE)
#define HCI_EVNT_WLAN_ASYNC_PING_REPORT (0x0040 + HCI_EVNT_WLAN_UNSOL_BASE)
#define HCI_EVNT_WLAN_ASYNC_SIMPLE_CONFIG_DONE (0x0080 + HCI_EVNT_WLAN_UNSOL_BASE)
#define HCI_EVNT_WLAN_KEEPALIVE (0x0200 + HCI_EVNT_WLAN_UNSOL_BASE)
#define HCI_EVNT_BSD_TCP_CLOSE_WAIT (0x0800 + HCI_EVNT_WLAN_UNSOL_BASE)
#define HCI_EVNT_DATA_UNSOL_FREE_BUFF \
0x4100
#define HCI_EVNT_NVMEM_CREATE_ENTRY \
HCI_CMND_NVMEM_CREATE_ENTRY
#define HCI_EVNT_NVMEM_SWAP_ENTRY HCI_CMND_NVMEM_SWAP_ENTRY
#define HCI_EVNT_NVMEM_READ HCI_CMND_NVMEM_READ
#define HCI_EVNT_NVMEM_WRITE (0x0202)
#define HCI_EVNT_READ_SP_VERSION \
HCI_CMND_READ_SP_VERSION
#define HCI_EVNT_INPROGRESS 0xFFFF
#define HCI_DATA_RECVFROM 0x84
#define HCI_DATA_RECV 0x85
#define HCI_DATA_NVMEM 0x91
#define HCI_EVENT_CC3000_CAN_SHUT_DOWN 0x99
//*****************************************************************************
//
// Prototypes for the structures for APIs.
//
//*****************************************************************************
#define HCI_DATA_HEADER_SIZE (5)
#define HCI_EVENT_HEADER_SIZE (5)
#define HCI_DATA_CMD_HEADER_SIZE (5)
#define HCI_PATCH_HEADER_SIZE (6)
#define HCI_PACKET_TYPE_OFFSET (0)
#define HCI_PACKET_ARGSIZE_OFFSET (2)
#define HCI_PACKET_LENGTH_OFFSET (3)
#define HCI_EVENT_OPCODE_OFFSET (1)
#define HCI_EVENT_LENGTH_OFFSET (3)
#define HCI_EVENT_STATUS_OFFSET (4)
#define HCI_DATA_LENGTH_OFFSET (3)
//*****************************************************************************
//
// Prototypes for the APIs.
//
//*****************************************************************************
//*****************************************************************************
//
//! hci_command_send
//!
//! @param usOpcode command operation code
//! @param pucBuff pointer to the command's arguments buffer
//! @param ucArgsLength length of the arguments
//!
//! @return none
//!
//! @brief Initiate an HCI command.
//
//*****************************************************************************
extern UINT16 hci_command_send(UINT16 usOpcode,
UINT8 *ucArgs,
UINT8 ucArgsLength);
//*****************************************************************************
//
//! hci_data_send
//!
//! @param usOpcode command operation code
//! @param ucArgs pointer to the command's arguments buffer
//! @param usArgsLength length of the arguments
//! @param ucTail pointer to the data buffer
//! @param usTailLength buffer length
//!
//! @return none
//!
//! @brief Initiate an HCI data write operation
//
//*****************************************************************************
extern INT32 hci_data_send(UINT8 ucOpcode,
UINT8 *ucArgs,
UINT16 usArgsLength,
UINT16 usDataLength,
const UINT8 *ucTail,
UINT16 usTailLength);
//*****************************************************************************
//
//! hci_data_command_send
//!
//! @param usOpcode command operation code
//! @param pucBuff pointer to the data buffer
//! @param ucArgsLength arguments length
//! @param ucDataLength data length
//!
//! @return none
//!
//! @brief Prepare HCI header and initiate an HCI data write operation
//
//*****************************************************************************
extern void hci_data_command_send(UINT16 usOpcode, UINT8 *pucBuff,
UINT8 ucArgsLength, UINT16 ucDataLength);
//*****************************************************************************
//
//! hci_patch_send
//!
//! @param usOpcode command operation code
//! @param pucBuff pointer to the command's arguments buffer
//! @param patch pointer to patch content buffer
//! @param usDataLength data length
//!
//! @return none
//!
//! @brief Prepare HCI header and initiate an HCI patch write operation
//
//*****************************************************************************
extern void hci_patch_send(UINT8 ucOpcode, UINT8 *pucBuff, CHAR *patch, UINT16 usDataLength);
//*****************************************************************************
//
// Mark the end of the C bindings section for C++ compilers.
//
//*****************************************************************************
#ifdef __cplusplus
}
#endif // __cplusplus
#endif // __CC3000_HCI_H__
| YifuLiu/AliOS-Things | components/py_engine/engine/drivers/cc3000/inc/hci.h | C | apache-2.0 | 12,275 |
/*****************************************************************************
*
* host_driver_version.h - CC3000 Host Driver Implementation.
* Copyright (C) 2011 Texas Instruments Incorporated - http://www.ti.com/
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the
* distribution.
*
* Neither the name of Texas Instruments Incorporated nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*****************************************************************************/
#ifndef __CC3000_HOST_DRIVER_VERSION_H__
#define __CC3000_HOST_DRIVER_VERSION_H__
#define DRIVER_VERSION_NUMBER 15
#endif // __CC3000_HOST_DRIVER_VERSION_H__
| YifuLiu/AliOS-Things | components/py_engine/engine/drivers/cc3000/inc/host_driver_version.h | C | apache-2.0 | 1,992 |
#ifndef __INET_NTOP_H
#define __INET_NTOP_H
char *inet_ntop(int af, const void *addr, char *buf, size_t size);
#endif /* __INET_NTOP_H */
| YifuLiu/AliOS-Things | components/py_engine/engine/drivers/cc3000/inc/inet_ntop.h | C | apache-2.0 | 138 |