mirror
/
micropython
kopia lustrzana https://github.com/micropython/micropython
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność

all: Use MP_ERROR_TEXT for all error messages.

pull/5861/head
Jim Mussared 2020-03-02 22:35:22 +11:00 zatwierdzone przez Damien George
rodzic 85858e72df
commit def76fe4d9
192 zmienionych plików z 823 dodań i 919 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

2
drivers/dht/dht.c
Wyświetl plik

@ -45,7 +45,7 @@ STATIC mp_obj_t dht_readinto(mp_obj_t pin_in, mp_obj_t buf_in) {
mp_get_buffer_raise(buf_in, &bufinfo, MP_BUFFER_WRITE);
if (bufinfo.len < 5) {
mp_raise_ValueError("buffer too small");
mp_raise_ValueError(MP_ERROR_TEXT("buffer too small"));
}
// issue start command

2
examples/natmod/features1/features1.c
Wyświetl plik

@ -45,7 +45,7 @@ STATIC mp_int_t fibonacci_helper(mp_int_t x) {
STATIC mp_obj_t fibonacci(mp_obj_t x_in) {
mp_int_t x = mp_obj_get_int(x_in);
if (x < 0) {
mp_raise_ValueError("can't compute negative Fibonacci number");
mp_raise_ValueError(MP_ERROR_TEXT("can't compute negative Fibonacci number"));
}
return mp_obj_new_int(fibonacci_helper(x));
}

2
examples/natmod/features2/main.c
Wyświetl plik

@ -52,7 +52,7 @@ STATIC mp_obj_t productf(mp_obj_fun_bc_t *self, size_t n_args, size_t n_kw, mp_o
mp_buffer_info_t bufinfo;
mp_get_buffer_raise(args[0], &bufinfo, MP_BUFFER_RW);
if (bufinfo.typecode != 'f') {
mp_raise_ValueError("expecting float array");
mp_raise_ValueError(MP_ERROR_TEXT("expecting float array"));
}
// Compute product, store result back in first element of array

2
examples/natmod/ure/ure.c
Wyświetl plik

@ -15,7 +15,7 @@ void mp_stack_check(void) {
// Assumes descending stack on target
volatile char dummy;
if (stack_top - &dummy >= STACK_LIMIT) {
mp_raise_msg(&mp_type_RuntimeError, "maximum recursion depth exceeded");
mp_raise_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("maximum recursion depth exceeded"));
}
}

10
extmod/machine_i2c.c
Wyświetl plik

@ -327,7 +327,7 @@ STATIC mp_obj_t machine_i2c_make_new(const mp_obj_type_t *type, size_t n_args, s
extern mp_obj_t MICROPY_PY_MACHINE_I2C_MAKE_NEW(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args);
return MICROPY_PY_MACHINE_I2C_MAKE_NEW(type, n_args, n_kw, args);
#else
mp_raise_ValueError("invalid I2C peripheral");
mp_raise_ValueError(MP_ERROR_TEXT("invalid I2C peripheral"));
#endif
}
--n_args;
@ -367,7 +367,7 @@ STATIC mp_obj_t machine_i2c_start(mp_obj_t self_in) {
mp_obj_base_t *self = (mp_obj_base_t *)MP_OBJ_TO_PTR(self_in);
mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t *)self->type->protocol;
if (i2c_p->start == NULL) {
mp_raise_msg(&mp_type_OSError, "I2C operation not supported");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("I2C operation not supported"));
}
int ret = i2c_p->start(self);
if (ret != 0) {
@ -381,7 +381,7 @@ STATIC mp_obj_t machine_i2c_stop(mp_obj_t self_in) {
mp_obj_base_t *self = (mp_obj_base_t *)MP_OBJ_TO_PTR(self_in);
mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t *)self->type->protocol;
if (i2c_p->stop == NULL) {
mp_raise_msg(&mp_type_OSError, "I2C operation not supported");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("I2C operation not supported"));
}
int ret = i2c_p->stop(self);
if (ret != 0) {
@ -395,7 +395,7 @@ STATIC mp_obj_t machine_i2c_readinto(size_t n_args, const mp_obj_t *args) {
mp_obj_base_t *self = (mp_obj_base_t *)MP_OBJ_TO_PTR(args[0]);
mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t *)self->type->protocol;
if (i2c_p->read == NULL) {
mp_raise_msg(&mp_type_OSError, "I2C operation not supported");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("I2C operation not supported"));
}
// get the buffer to read into
@ -419,7 +419,7 @@ STATIC mp_obj_t machine_i2c_write(mp_obj_t self_in, mp_obj_t buf_in) {
mp_obj_base_t *self = (mp_obj_base_t *)MP_OBJ_TO_PTR(self_in);
mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t *)self->type->protocol;
if (i2c_p->write == NULL) {
mp_raise_msg(&mp_type_OSError, "I2C operation not supported");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("I2C operation not supported"));
}
// get the buffer to write from

2
extmod/machine_mem.c
Wyświetl plik

@ -42,7 +42,7 @@
STATIC uintptr_t machine_mem_get_addr(mp_obj_t addr_o, uint align) {
uintptr_t addr = mp_obj_int_get_truncated(addr_o);
if ((addr & (align - 1)) != 0) {
mp_raise_msg_varg(&mp_type_ValueError, "address %08x is not aligned to %d bytes", addr, align);
mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("address %08x is not aligned to %d bytes"), addr, align);
}
return addr;
}

10
extmod/machine_spi.c
Wyświetl plik

@ -52,7 +52,7 @@ mp_obj_t mp_machine_spi_make_new(const mp_obj_type_t *type, size_t n_args, size_
extern mp_obj_t MICROPY_PY_MACHINE_SPI_MAKE_NEW(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args);
return MICROPY_PY_MACHINE_SPI_MAKE_NEW(type, n_args, n_kw, args);
#else
mp_raise_ValueError("invalid SPI peripheral");
mp_raise_ValueError(MP_ERROR_TEXT("invalid SPI peripheral"));
#endif
}
--n_args;
@ -119,7 +119,7 @@ STATIC mp_obj_t mp_machine_spi_write_readinto(mp_obj_t self, mp_obj_t wr_buf, mp
mp_buffer_info_t dest;
mp_get_buffer_raise(rd_buf, &dest, MP_BUFFER_WRITE);
if (src.len != dest.len) {
mp_raise_ValueError("buffers must be the same length");
mp_raise_ValueError(MP_ERROR_TEXT("buffers must be the same length"));
}
mp_machine_spi_transfer(self, src.len, src.buf, dest.buf);
return mp_const_none;
@ -202,15 +202,15 @@ STATIC mp_obj_t mp_machine_soft_spi_make_new(const mp_obj_type_t *type, size_t n
self->spi.polarity = args[ARG_polarity].u_int;
self->spi.phase = args[ARG_phase].u_int;
if (args[ARG_bits].u_int != 8) {
mp_raise_ValueError("bits must be 8");
mp_raise_ValueError(MP_ERROR_TEXT("bits must be 8"));
}
if (args[ARG_firstbit].u_int != MICROPY_PY_MACHINE_SPI_MSB) {
mp_raise_ValueError("firstbit must be MSB");
mp_raise_ValueError(MP_ERROR_TEXT("firstbit must be MSB"));
}
if (args[ARG_sck].u_obj == MP_OBJ_NULL
|| args[ARG_mosi].u_obj == MP_OBJ_NULL
|| args[ARG_miso].u_obj == MP_OBJ_NULL) {
mp_raise_ValueError("must specify all of sck/mosi/miso");
mp_raise_ValueError(MP_ERROR_TEXT("must specify all of sck/mosi/miso"));
}
self->spi.sck = mp_hal_get_pin_obj(args[ARG_sck].u_obj);
self->spi.mosi = mp_hal_get_pin_obj(args[ARG_mosi].u_obj);

28
extmod/modbluetooth.c
Wyświetl plik

@ -91,7 +91,7 @@ STATIC mp_obj_t bluetooth_uuid_make_new(const mp_obj_type_t *type, size_t n_args
self->type = MP_BLUETOOTH_UUID_TYPE_16;
mp_int_t value = mp_obj_get_int(all_args[0]);
if (value > 65535) {
mp_raise_ValueError("invalid UUID");
mp_raise_ValueError(MP_ERROR_TEXT("invalid UUID"));
}
self->data[0] = value & 0xff;
self->data[1] = (value >> 8) & 0xff;
@ -112,12 +112,12 @@ STATIC mp_obj_t bluetooth_uuid_make_new(const mp_obj_type_t *type, size_t n_args
continue;
}
if (!unichar_isxdigit(c)) {
mp_raise_ValueError("invalid char in UUID");
mp_raise_ValueError(MP_ERROR_TEXT("invalid char in UUID"));
}
c = unichar_xdigit_value(c);
uuid_i--;
if (uuid_i < 0) {
mp_raise_ValueError("UUID too long");
mp_raise_ValueError(MP_ERROR_TEXT("UUID too long"));
}
if (uuid_i % 2 == 0) {
// lower nibble
@ -128,7 +128,7 @@ STATIC mp_obj_t bluetooth_uuid_make_new(const mp_obj_type_t *type, size_t n_args
}
}
if (uuid_i > 0) {
mp_raise_ValueError("UUID too short");
mp_raise_ValueError(MP_ERROR_TEXT("UUID too short"));
}
}
}
@ -283,7 +283,7 @@ STATIC mp_obj_t bluetooth_ble_config(size_t n_args, const mp_obj_t *args, mp_map
if (kwargs->used == 0) {
// Get config value
if (n_args != 2) {
mp_raise_TypeError("must query one param");
mp_raise_TypeError(MP_ERROR_TEXT("must query one param"));
}
switch (mp_obj_str_get_qstr(args[1])) {
@ -295,12 +295,12 @@ STATIC mp_obj_t bluetooth_ble_config(size_t n_args, const mp_obj_t *args, mp_map
case MP_QSTR_rxbuf:
return mp_obj_new_int(self->ringbuf.size);
default:
mp_raise_ValueError("unknown config param");
mp_raise_ValueError(MP_ERROR_TEXT("unknown config param"));
}
} else {
// Set config value(s)
if (n_args != 1) {
mp_raise_TypeError("can't specify pos and kw args");
mp_raise_TypeError(MP_ERROR_TEXT("can't specify pos and kw args"));
}
for (size_t i = 0; i < kwargs->alloc; ++i) {
@ -341,7 +341,7 @@ STATIC mp_obj_t bluetooth_ble_config(size_t n_args, const mp_obj_t *args, mp_map
break;
}
default:
mp_raise_ValueError("unknown config param");
mp_raise_ValueError(MP_ERROR_TEXT("unknown config param"));
}
}
}
@ -361,7 +361,7 @@ STATIC mp_obj_t bluetooth_ble_irq(size_t n_args, const mp_obj_t *pos_args, mp_ma
mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
mp_obj_t callback = args[ARG_handler].u_obj;
if (callback != mp_const_none && !mp_obj_is_callable(callback)) {
mp_raise_ValueError("invalid callback");
mp_raise_ValueError(MP_ERROR_TEXT("invalid callback"));
}
// Update the callback.
@ -414,7 +414,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_KW(bluetooth_ble_gap_advertise_obj, 1, bluetooth_
STATIC int bluetooth_gatts_register_service(mp_obj_t uuid_in, mp_obj_t characteristics_in, uint16_t **handles, size_t *num_handles) {
if (!mp_obj_is_type(uuid_in, &bluetooth_uuid_type)) {
mp_raise_ValueError("invalid service UUID");
mp_raise_ValueError(MP_ERROR_TEXT("invalid service UUID"));
}
mp_obj_bluetooth_uuid_t *service_uuid = MP_OBJ_TO_PTR(uuid_in);
@ -451,11 +451,11 @@ STATIC int bluetooth_gatts_register_service(mp_obj_t uuid_in, mp_obj_t character
mp_obj_get_array(characteristic_obj, &characteristic_len, &characteristic_items);
if (characteristic_len < 2 || characteristic_len > 3) {
mp_raise_ValueError("invalid characteristic tuple");
mp_raise_ValueError(MP_ERROR_TEXT("invalid characteristic tuple"));
}
mp_obj_t uuid_obj = characteristic_items[0];
if (!mp_obj_is_type(uuid_obj, &bluetooth_uuid_type)) {
mp_raise_ValueError("invalid characteristic UUID");
mp_raise_ValueError(MP_ERROR_TEXT("invalid characteristic UUID"));
}
(*handles)[handle_index++] = 0xffff;
@ -487,7 +487,7 @@ STATIC int bluetooth_gatts_register_service(mp_obj_t uuid_in, mp_obj_t character
mp_obj_get_array_fixed_n(descriptor_obj, 2, &descriptor_items);
mp_obj_t desc_uuid_obj = descriptor_items[0];
if (!mp_obj_is_type(desc_uuid_obj, &bluetooth_uuid_type)) {
mp_raise_ValueError("invalid descriptor UUID");
mp_raise_ValueError(MP_ERROR_TEXT("invalid descriptor UUID"));
}
descriptor_uuids[descriptor_index] = MP_OBJ_TO_PTR(desc_uuid_obj);
@ -567,7 +567,7 @@ STATIC mp_obj_t bluetooth_ble_gap_connect(size_t n_args, const mp_obj_t *args) {
mp_buffer_info_t bufinfo = {0};
mp_get_buffer_raise(args[2], &bufinfo, MP_BUFFER_READ);
if (bufinfo.len != 6) {
mp_raise_ValueError("invalid addr");
mp_raise_ValueError(MP_ERROR_TEXT("invalid addr"));
}
mp_int_t scan_duration_ms = MP_BLUETOOTH_CONNECT_DEFAULT_SCAN_DURATION_MS;
if (n_args == 4) {

2
extmod/modframebuf.c
Wyświetl plik

@ -300,7 +300,7 @@ STATIC mp_obj_t framebuf_make_new(const mp_obj_type_t *type, size_t n_args, size
case FRAMEBUF_GS8:
break;
default:
mp_raise_ValueError("invalid format");
mp_raise_ValueError(MP_ERROR_TEXT("invalid format"));
}
return MP_OBJ_FROM_PTR(o);

6
extmod/modlwip.c
Wyświetl plik

@ -144,15 +144,15 @@ STATIC mp_obj_t lwip_slip_make_new(mp_obj_t type_in, size_t n_args, size_t n_kw,
ip_addr_t iplocal, ipremote;
if (!ipaddr_aton(mp_obj_str_get_str(args[1]), &iplocal)) {
mp_raise_ValueError("not a valid local IP");
mp_raise_ValueError(MP_ERROR_TEXT("not a valid local IP"));
}
if (!ipaddr_aton(mp_obj_str_get_str(args[2]), &ipremote)) {
mp_raise_ValueError("not a valid remote IP");
mp_raise_ValueError(MP_ERROR_TEXT("not a valid remote IP"));
}
struct netif *n = &lwip_slip_obj.lwip_netif;
if (netif_add(n, &iplocal, IP_ADDR_BROADCAST, &ipremote, NULL, slipif_init, ip_input) == NULL) {
mp_raise_ValueError("out of memory");
mp_raise_ValueError(MP_ERROR_TEXT("out of memory"));
}
netif_set_up(n);
netif_set_default(n);

4
extmod/moduasyncio.c
Wyświetl plik

@ -112,7 +112,7 @@ STATIC mp_obj_t task_queue_pop_head(mp_obj_t self_in) {
mp_obj_task_queue_t *self = MP_OBJ_TO_PTR(self_in);
mp_obj_task_t *head = (mp_obj_task_t *)mp_pairheap_peek(task_lt, &self->heap->pairheap);
if (head == NULL) {
mp_raise_msg(&mp_type_IndexError, "empty heap");
mp_raise_msg(&mp_type_IndexError, MP_ERROR_TEXT("empty heap"));
}
self->heap = (mp_obj_task_t *)mp_pairheap_pop(task_lt, &self->heap->pairheap);
return MP_OBJ_FROM_PTR(head);
@ -173,7 +173,7 @@ STATIC mp_obj_t task_cancel(mp_obj_t self_in) {
// Can't cancel self (not supported yet).
mp_obj_t cur_task = mp_obj_dict_get(uasyncio_context, MP_OBJ_NEW_QSTR(MP_QSTR_cur_task));
if (self_in == cur_task) {
mp_raise_msg(&mp_type_RuntimeError, "cannot cancel self");
mp_raise_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("cannot cancel self"));
}
// If Task waits on another task then forward the cancel to the one it's waiting on.
while (mp_obj_is_subclass_fast(MP_OBJ_FROM_PTR(mp_obj_get_type(self->data)), MP_OBJ_FROM_PTR(&task_type))) {

6
extmod/modubinascii.c
Wyświetl plik

@ -79,7 +79,7 @@ STATIC mp_obj_t mod_binascii_unhexlify(mp_obj_t data) {
mp_get_buffer_raise(data, &bufinfo, MP_BUFFER_READ);
if ((bufinfo.len & 1) != 0) {
mp_raise_ValueError("odd-length string");
mp_raise_ValueError(MP_ERROR_TEXT("odd-length string"));
}
vstr_t vstr;
vstr_init_len(&vstr, bufinfo.len / 2);
@ -90,7 +90,7 @@ STATIC mp_obj_t mod_binascii_unhexlify(mp_obj_t data) {
if (unichar_isxdigit(hex_ch)) {
hex_byte += unichar_xdigit_value(hex_ch);
} else {
mp_raise_ValueError("non-hex digit found");
mp_raise_ValueError(MP_ERROR_TEXT("non-hex digit found"));
}
if (i & 1) {
hex_byte <<= 4;
@ -158,7 +158,7 @@ STATIC mp_obj_t mod_binascii_a2b_base64(mp_obj_t data) {
}
if (nbits) {
mp_raise_ValueError("incorrect padding");
mp_raise_ValueError(MP_ERROR_TEXT("incorrect padding"));
}
return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);

14
extmod/moducryptolib.c
Wyświetl plik

@ -225,7 +225,7 @@ STATIC mp_obj_t ucryptolib_aes_make_new(const mp_obj_type_t *type, size_t n_args
break;
default:
mp_raise_ValueError("mode");
mp_raise_ValueError(MP_ERROR_TEXT("mode"));
}
mp_obj_aes_t *o = m_new_obj_var(mp_obj_aes_t, struct ctr_params, !!is_ctr_mode(block_mode));
@ -237,7 +237,7 @@ STATIC mp_obj_t ucryptolib_aes_make_new(const mp_obj_type_t *type, size_t n_args
mp_buffer_info_t keyinfo;
mp_get_buffer_raise(args[0], &keyinfo, MP_BUFFER_READ);
if (32 != keyinfo.len && 16 != keyinfo.len) {
mp_raise_ValueError("key");
mp_raise_ValueError(MP_ERROR_TEXT("key"));
}
mp_buffer_info_t ivinfo;
@ -246,10 +246,10 @@ STATIC mp_obj_t ucryptolib_aes_make_new(const mp_obj_type_t *type, size_t n_args
mp_get_buffer_raise(args[2], &ivinfo, MP_BUFFER_READ);
if (16 != ivinfo.len) {
mp_raise_ValueError("IV");
mp_raise_ValueError(MP_ERROR_TEXT("IV"));
}
} else if (o->block_mode == UCRYPTOLIB_MODE_CBC || is_ctr_mode(o->block_mode)) {
mp_raise_ValueError("IV");
mp_raise_ValueError(MP_ERROR_TEXT("IV"));
}
if (is_ctr_mode(block_mode)) {
@ -274,7 +274,7 @@ STATIC mp_obj_t aes_process(size_t n_args, const mp_obj_t *args, bool encrypt) {
mp_get_buffer_raise(in_buf, &in_bufinfo, MP_BUFFER_READ);
if (!is_ctr_mode(self->block_mode) && in_bufinfo.len % 16 != 0) {
mp_raise_ValueError("blksize % 16");
mp_raise_ValueError(MP_ERROR_TEXT("blksize % 16"));
}
vstr_t vstr;
@ -284,7 +284,7 @@ STATIC mp_obj_t aes_process(size_t n_args, const mp_obj_t *args, bool encrypt) {
if (out_buf != MP_OBJ_NULL) {
mp_get_buffer_raise(out_buf, &out_bufinfo, MP_BUFFER_WRITE);
if (out_bufinfo.len < in_bufinfo.len) {
mp_raise_ValueError("output too small");
mp_raise_ValueError(MP_ERROR_TEXT("output too small"));
}
out_buf_ptr = out_bufinfo.buf;
} else {
@ -301,7 +301,7 @@ STATIC mp_obj_t aes_process(size_t n_args, const mp_obj_t *args, bool encrypt) {
if ((encrypt && self->key_type == AES_KEYTYPE_DEC) ||
(!encrypt && self->key_type == AES_KEYTYPE_ENC)) {
mp_raise_ValueError("can't encrypt & decrypt");
mp_raise_ValueError(MP_ERROR_TEXT("can't encrypt & decrypt"));
}
}

10
extmod/moductypes.c
Wyświetl plik

@ -117,7 +117,7 @@ typedef struct _mp_obj_uctypes_struct_t {
} mp_obj_uctypes_struct_t;
STATIC NORETURN void syntax_error(void) {
mp_raise_TypeError("syntax error in uctypes descriptor");
mp_raise_TypeError(MP_ERROR_TEXT("syntax error in uctypes descriptor"));
}
STATIC mp_obj_t uctypes_struct_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
@ -226,7 +226,7 @@ STATIC mp_uint_t uctypes_struct_size(mp_obj_t desc_in, int layout_type, mp_uint_
// but scalar structure field is lowered into native Python int, so all
// type info is lost. So, we cannot say if it's scalar type description,
// or such lowered scalar.
mp_raise_TypeError("Cannot unambiguously get sizeof scalar");
mp_raise_TypeError(MP_ERROR_TEXT("Cannot unambiguously get sizeof scalar"));
}
syntax_error();
}
@ -424,7 +424,7 @@ STATIC mp_obj_t uctypes_struct_attr_op(mp_obj_t self_in, qstr attr, mp_obj_t set
&& !mp_obj_is_type(self->desc, &mp_type_ordereddict)
#endif
) {
mp_raise_TypeError("struct: no fields");
mp_raise_TypeError(MP_ERROR_TEXT("struct: no fields"));
}
mp_obj_t deref = mp_obj_dict_get(self->desc, MP_OBJ_NEW_QSTR(attr));
@ -557,7 +557,7 @@ STATIC mp_obj_t uctypes_struct_subscr(mp_obj_t self_in, mp_obj_t index_in, mp_ob
} else {
// load / store
if (!mp_obj_is_type(self->desc, &mp_type_tuple)) {
mp_raise_TypeError("struct: cannot index");
mp_raise_TypeError(MP_ERROR_TEXT("struct: cannot index"));
}
mp_obj_tuple_t *t = MP_OBJ_TO_PTR(self->desc);
@ -571,7 +571,7 @@ STATIC mp_obj_t uctypes_struct_subscr(mp_obj_t self_in, mp_obj_t index_in, mp_ob
uint val_type = GET_TYPE(arr_sz, VAL_TYPE_BITS);
arr_sz &= VALUE_MASK(VAL_TYPE_BITS);
if (index >= arr_sz) {
mp_raise_msg(&mp_type_IndexError, "struct: index out of range");
mp_raise_msg(&mp_type_IndexError, MP_ERROR_TEXT("struct: index out of range"));
}
if (t->len == 2) {

4
extmod/moduheapq.c
Wyświetl plik

@ -33,7 +33,7 @@
STATIC mp_obj_list_t *uheapq_get_heap(mp_obj_t heap_in) {
if (!mp_obj_is_type(heap_in, &mp_type_list)) {
mp_raise_TypeError("heap must be a list");
mp_raise_TypeError(MP_ERROR_TEXT("heap must be a list"));
}
return MP_OBJ_TO_PTR(heap_in);
}
@ -81,7 +81,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_2(mod_uheapq_heappush_obj, mod_uheapq_heappush);
STATIC mp_obj_t mod_uheapq_heappop(mp_obj_t heap_in) {
mp_obj_list_t *heap = uheapq_get_heap(heap_in);
if (heap->len == 0) {
mp_raise_msg(&mp_type_IndexError, "empty heap");
mp_raise_msg(&mp_type_IndexError, MP_ERROR_TEXT("empty heap"));
}
mp_obj_t item = heap->items[0];
heap->len -= 1;

2
extmod/modujson.c
Wyświetl plik

@ -295,7 +295,7 @@ success:
return stack_top;
fail:
mp_raise_ValueError("syntax error in JSON");
mp_raise_ValueError(MP_ERROR_TEXT("syntax error in JSON"));
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(mod_ujson_load_obj, mod_ujson_load);

4
extmod/modure.c
Wyświetl plik

@ -235,7 +235,7 @@ STATIC mp_obj_t re_split(size_t n_args, const mp_obj_t *args) {
mp_obj_t s = mp_obj_new_str_of_type(str_type, (const byte *)subj.begin, caps[0] - subj.begin);
mp_obj_list_append(retval, s);
if (self->re.sub > 0) {
mp_raise_NotImplementedError("Splitting with sub-captures");
mp_raise_NotImplementedError(MP_ERROR_TEXT("Splitting with sub-captures"));
}
subj.begin = caps[1];
if (maxsplit > 0 && --maxsplit == 0) {
@ -403,7 +403,7 @@ STATIC mp_obj_t mod_re_compile(size_t n_args, const mp_obj_t *args) {
int error = re1_5_compilecode(&o->re, re_str);
if (error != 0) {
error:
mp_raise_ValueError("Error in regex");
mp_raise_ValueError(MP_ERROR_TEXT("Error in regex"));
}
#if MICROPY_PY_URE_DEBUG
if (flags & FLAG_DEBUG) {

4
extmod/modussl_axtls.c
Wyświetl plik

@ -82,13 +82,13 @@ STATIC mp_obj_ssl_socket_t *ussl_socket_new(mp_obj_t sock, struct ssl_args *args
const byte *data = (const byte *)mp_obj_str_get_data(args->key.u_obj, &len);
int res = ssl_obj_memory_load(o->ssl_ctx, SSL_OBJ_RSA_KEY, data, len, NULL);
if (res != SSL_OK) {
mp_raise_ValueError("invalid key");
mp_raise_ValueError(MP_ERROR_TEXT("invalid key"));
}
data = (const byte *)mp_obj_str_get_data(args->cert.u_obj, &len);
res = ssl_obj_memory_load(o->ssl_ctx, SSL_OBJ_X509_CERT, data, len, NULL);
if (res != SSL_OK) {
mp_raise_ValueError("invalid cert");
mp_raise_ValueError(MP_ERROR_TEXT("invalid cert"));
}
}

4
extmod/modussl_mbedtls.c
Wyświetl plik

@ -217,9 +217,9 @@ cleanup:
if (ret == MBEDTLS_ERR_SSL_ALLOC_FAILED) {
mp_raise_OSError(MP_ENOMEM);
} else if (ret == MBEDTLS_ERR_PK_BAD_INPUT_DATA) {
mp_raise_ValueError("invalid key");
mp_raise_ValueError(MP_ERROR_TEXT("invalid key"));
} else if (ret == MBEDTLS_ERR_X509_BAD_INPUT_DATA) {
mp_raise_ValueError("invalid cert");
mp_raise_ValueError(MP_ERROR_TEXT("invalid cert"));
} else {
mp_raise_OSError(MP_EIO);
}

6
extmod/modutimeq.c
Wyświetl plik

@ -126,7 +126,7 @@ STATIC mp_obj_t mod_utimeq_heappush(size_t n_args, const mp_obj_t *args) {
mp_obj_t heap_in = args[0];
mp_obj_utimeq_t *heap = utimeq_get_heap(heap_in);
if (heap->len == heap->alloc) {
mp_raise_msg(&mp_type_IndexError, "queue overflow");
mp_raise_msg(&mp_type_IndexError, MP_ERROR_TEXT("queue overflow"));
}
mp_uint_t l = heap->len;
heap->items[l].time = MP_OBJ_SMALL_INT_VALUE(args[1]);
@ -142,7 +142,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mod_utimeq_heappush_obj, 4, 4, mod_ut
STATIC mp_obj_t mod_utimeq_heappop(mp_obj_t heap_in, mp_obj_t list_ref) {
mp_obj_utimeq_t *heap = utimeq_get_heap(heap_in);
if (heap->len == 0) {
mp_raise_msg(&mp_type_IndexError, "empty heap");
mp_raise_msg(&mp_type_IndexError, MP_ERROR_TEXT("empty heap"));
}
mp_obj_list_t *ret = MP_OBJ_TO_PTR(list_ref);
if (!mp_obj_is_type(list_ref, &mp_type_list) || ret->len < 3) {
@ -167,7 +167,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_2(mod_utimeq_heappop_obj, mod_utimeq_heappop);
STATIC mp_obj_t mod_utimeq_peektime(mp_obj_t heap_in) {
mp_obj_utimeq_t *heap = utimeq_get_heap(heap_in);
if (heap->len == 0) {
mp_raise_msg(&mp_type_IndexError, "empty heap");
mp_raise_msg(&mp_type_IndexError, MP_ERROR_TEXT("empty heap"));
}
struct qentry *item = &heap->items[0];

2
extmod/moduzlib.c
Wyświetl plik

@ -92,7 +92,7 @@ STATIC mp_obj_t decompio_make_new(const mp_obj_type_t *type, size_t n_args, size
dict_opt = uzlib_zlib_parse_header(&o->decomp);
if (dict_opt < 0) {
header_error:
mp_raise_ValueError("compression header");
mp_raise_ValueError(MP_ERROR_TEXT("compression header"));
}
dict_sz = 1 << dict_opt;
} else {

14
extmod/network_cyw43.c
Wyświetl plik

@ -196,7 +196,7 @@ STATIC mp_obj_t network_cyw43_scan(size_t n_args, const mp_obj_t *pos_args, mp_m
int scan_res = cyw43_wifi_scan(self->cyw, &opts, MP_OBJ_TO_PTR(res), network_cyw43_scan_cb);
if (scan_res < 0) {
mp_raise_msg(&mp_type_OSError, "STA must be active");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("STA must be active"));
}
// Wait for scan to finish, with a 10s timeout
@ -279,7 +279,7 @@ STATIC mp_obj_t network_cyw43_status(size_t n_args, const mp_obj_t *args) {
case MP_QSTR_stations: {
// return list of connected stations
if (self->itf != CYW43_ITF_AP) {
mp_raise_ValueError("AP required");
mp_raise_ValueError(MP_ERROR_TEXT("AP required"));
}
int num_stas;
uint8_t macs[32 * 6];
@ -295,7 +295,7 @@ STATIC mp_obj_t network_cyw43_status(size_t n_args, const mp_obj_t *args) {
}
}
mp_raise_ValueError("unknown status param");
mp_raise_ValueError(MP_ERROR_TEXT("unknown status param"));
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(network_cyw43_status_obj, 1, 2, network_cyw43_status);
@ -316,7 +316,7 @@ STATIC mp_obj_t network_cyw43_config(size_t n_args, const mp_obj_t *args, mp_map
if (kwargs->used == 0) {
// Get config value
if (n_args != 2) {
mp_raise_TypeError("must query one param");
mp_raise_TypeError(MP_ERROR_TEXT("must query one param"));
}
switch (mp_obj_str_get_qstr(args[1])) {
@ -354,12 +354,12 @@ STATIC mp_obj_t network_cyw43_config(size_t n_args, const mp_obj_t *args, mp_map
return MP_OBJ_NEW_SMALL_INT(nw_get_le32(buf) / 4);
}
default:
mp_raise_ValueError("unknown config param");
mp_raise_ValueError(MP_ERROR_TEXT("unknown config param"));
}
} else {
// Set config value(s)
if (n_args != 1) {
mp_raise_TypeError("can't specify pos and kw args");
mp_raise_TypeError(MP_ERROR_TEXT("can't specify pos and kw args"));
}
for (size_t i = 0; i < kwargs->alloc; ++i) {
@ -420,7 +420,7 @@ STATIC mp_obj_t network_cyw43_config(size_t n_args, const mp_obj_t *args, mp_map
break;
}
default:
mp_raise_ValueError("unknown config param");
mp_raise_ValueError(MP_ERROR_TEXT("unknown config param"));
}
}
}

2
extmod/uos_dupterm.c
Wyświetl plik

@ -179,7 +179,7 @@ STATIC mp_obj_t mp_uos_dupterm(size_t n_args, const mp_obj_t *args) {
}
if (idx < 0 || idx >= MICROPY_PY_OS_DUPTERM) {
mp_raise_ValueError("invalid dupterm index");
mp_raise_ValueError(MP_ERROR_TEXT("invalid dupterm index"));
}
mp_obj_t previous_obj = MP_STATE_VM(dupterm_objs[idx]);

2
extmod/vfs_posix_file.c
Wyświetl plik

@ -47,7 +47,7 @@ typedef struct _mp_obj_vfs_posix_file_t {
#ifdef MICROPY_CPYTHON_COMPAT
STATIC void check_fd_is_open(const mp_obj_vfs_posix_file_t *o) {
if (o->fd < 0) {
mp_raise_ValueError("I/O operation on closed file");
mp_raise_ValueError(MP_ERROR_TEXT("I/O operation on closed file"));
}
}
#else

2
lib/embed/abort_.c
Wyświetl plik

@ -3,5 +3,5 @@
NORETURN void abort_(void);
NORETURN void abort_(void) {
mp_raise_msg(&mp_type_RuntimeError, "abort() called");
mp_raise_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("abort() called"));
}

2
lib/netutils/netutils.c
Wyświetl plik

@ -79,7 +79,7 @@ void netutils_parse_ipv4_addr(mp_obj_t addr_in, uint8_t *out_ip, netutils_endian
} else if (i > 0 && s < s_top && *s == '.') {
s++;
} else {
mp_raise_ValueError("invalid arguments");
mp_raise_ValueError(MP_ERROR_TEXT("invalid arguments"));
}
}
}

13
ports/cc3200/application.mk
Wyświetl plik

@ -73,7 +73,6 @@ APP_MISC_SRC_C = $(addprefix misc/,\
help.c \
mpirq.c \
mperror.c \
mpexception.c \
)
APP_MODS_SRC_C = $(addprefix mods/,\
@ -112,12 +111,12 @@ APP_CC3100_SRC_C = $(addprefix drivers/cc3100/src/,\
APP_SL_SRC_C = $(addprefix simplelink/,\
oslib/osi_freertos.c \
cc_pal.c \
)
)
APP_TELNET_SRC_C = $(addprefix telnet/,\
telnet.c \
)
APP_UTIL_SRC_C = $(addprefix util/,\
cryptohash.c \
fifo.c \
@ -125,18 +124,18 @@ APP_UTIL_SRC_C = $(addprefix util/,\
random.c \
socketfifo.c \
)
APP_UTIL_SRC_S = $(addprefix util/,\
sleeprestore.s \
)
APP_MAIN_SRC_C = \
main.c \
mptask.c \
mpthreadport.c \
serverstask.c \
fatfs_port.c \
APP_LIB_SRC_C = $(addprefix lib/,\
oofatfs/ff.c \
oofatfs/ffunicode.c \
@ -148,7 +147,7 @@ APP_LIB_SRC_C = $(addprefix lib/,\
utils/interrupt_char.c \
utils/sys_stdio_mphal.c \
)
APP_STM_SRC_C = $(addprefix ports/stm32/,\
bufhelper.c \
irq.c \

1
ports/cc3200/hal/cc3200_hal.c
Wyświetl plik

@ -45,7 +45,6 @@
#include "systick.h"
#include "prcm.h"
#include "pin.h"
#include "mpexception.h"
#include "telnet.h"
#include "pybuart.h"
#include "utils.h"

39
ports/cc3200/misc/mpexception.c
Wyświetl plik

@ -1,39 +0,0 @@
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2013, 2014 Damien P. George
* Copyright (c) 2015 Daniel Campora
*
* 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 <string.h>
#include "mpexception.h"
/******************************************************************************
DECLARE EXPORTED DATA
******************************************************************************/
const char mpexception_value_invalid_arguments[] = "invalid argument(s) value";
const char mpexception_num_type_invalid_arguments[] = "invalid argument(s) num/type";
const char mpexception_uncaught[] = "uncaught exception";

34
ports/cc3200/misc/mpexception.h
Wyświetl plik

@ -1,34 +0,0 @@
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2013, 2014 Damien P. George
* Copyright (c) 2015 Daniel Campora
*
* 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_CC3200_MISC_MPEXCEPTION_H
#define MICROPY_INCLUDED_CC3200_MISC_MPEXCEPTION_H
extern const char mpexception_value_invalid_arguments[];
extern const char mpexception_num_type_invalid_arguments[];
extern const char mpexception_uncaught[];
#endif // MICROPY_INCLUDED_CC3200_MISC_MPEXCEPTION_H

3
ports/cc3200/misc/mpirq.c
Wyświetl plik

@ -33,7 +33,6 @@
#include "inc/hw_types.h"
#include "interrupt.h"
#include "pybsleep.h"
#include "mpexception.h"
#include "mperror.h"
#include "mpirq.h"
@ -112,7 +111,7 @@ void mp_irq_remove (const mp_obj_t parent) {
uint mp_irq_translate_priority (uint priority) {
if (priority < 1 || priority > MP_ARRAY_SIZE(mp_irq_priorities)) {
mp_raise_ValueError(mpexception_value_invalid_arguments);
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
}
return mp_irq_priorities[priority - 1];
}

3
ports/cc3200/mods/modmachine.c
Wyświetl plik

@ -47,7 +47,6 @@
#include "FreeRTOS.h"
#include "portable.h"
#include "task.h"
#include "mpexception.h"
#include "random.h"
#include "pybadc.h"
#include "pybi2c.h"
@ -125,7 +124,7 @@ STATIC mp_obj_t machine_main(mp_obj_t main) {
if (mp_obj_is_str(main)) {
MP_STATE_PORT(machine_config_main) = main;
} else {
mp_raise_ValueError(mpexception_value_invalid_arguments);
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
}
return mp_const_none;
}

1
ports/cc3200/mods/modnetwork.c
Wyświetl plik

@ -29,7 +29,6 @@
#include "py/mperrno.h"
#include "py/mphal.h"
#include "modnetwork.h"
#include "mpexception.h"
#include "serverstask.h"
#include "simplelink.h"

1
ports/cc3200/mods/moduhashlib.c
Wyświetl plik

@ -41,7 +41,6 @@
#include "prcm.h"
#include "shamd5.h"
#include "cryptohash.h"
#include "mpexception.h"
/******************************************************************************

1
ports/cc3200/mods/moduos.c
Wyświetl plik

@ -40,7 +40,6 @@
#include "extmod/vfs.h"
#include "extmod/vfs_fat.h"
#include "random.h"
#include "mpexception.h"
#include "version.h"
#include "pybsd.h"
#include "pybuart.h"

1
ports/cc3200/mods/modusocket.c
Wyświetl plik

@ -38,7 +38,6 @@
#include "lib/netutils/netutils.h"
#include "modnetwork.h"
#include "modusocket.h"
#include "mpexception.h"
/******************************************************************************/
// The following set of macros and functions provide a glue between the CC3100

3
ports/cc3200/mods/modussl.c
Wyświetl plik

@ -33,7 +33,6 @@
#include "py/runtime.h"
#include "modnetwork.h"
#include "modusocket.h"
#include "mpexception.h"
/******************************************************************************
DEFINE CONSTANTS
@ -133,7 +132,7 @@ socket_error:
mp_raise_OSError(_errno);
arg_error:
mp_raise_ValueError(mpexception_value_invalid_arguments);
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
}
STATIC MP_DEFINE_CONST_FUN_OBJ_KW(mod_ssl_wrap_socket_obj, 0, mod_ssl_wrap_socket);

3
ports/cc3200/mods/modutime.c
Wyświetl plik

@ -42,7 +42,6 @@
#include "prcm.h"
#include "systick.h"
#include "pybrtc.h"
#include "mpexception.h"
#include "utils.h"
/// \module time - time related functions
@ -109,7 +108,7 @@ STATIC mp_obj_t time_mktime(mp_obj_t tuple) {
// localtime generates a tuple of len 8. CPython uses 9, so we accept both.
if (len < 8 || len > 9) {
mp_raise_TypeError(mpexception_num_type_invalid_arguments);
mp_raise_TypeError(MP_ERROR_TEXT("invalid argument(s) num/type"));
}
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]),

21
ports/cc3200/mods/modwlan.c
Wyświetl plik

@ -45,7 +45,6 @@
#if (MICROPY_PORT_HAS_TELNET || MICROPY_PORT_HAS_FTP)
#include "serverstask.h"
#endif
#include "mpexception.h"
#include "mpirq.h"
#include "pybsleep.h"
#include "antenna.h"
@ -589,7 +588,7 @@ STATIC void wlan_reset (void) {
STATIC void wlan_validate_mode (uint mode) {
if (mode != ROLE_STA && mode != ROLE_AP) {
mp_raise_ValueError(mpexception_value_invalid_arguments);
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
}
}
@ -600,7 +599,7 @@ STATIC void wlan_set_mode (uint mode) {
STATIC void wlan_validate_ssid_len (uint32_t len) {
if (len > MODWLAN_SSID_LEN_MAX) {
mp_raise_ValueError(mpexception_value_invalid_arguments);
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
}
}
@ -633,7 +632,7 @@ STATIC void wlan_validate_security (uint8_t auth, const char *key, uint8_t len)
return;
invalid_args:
mp_raise_ValueError(mpexception_value_invalid_arguments);
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
}
STATIC void wlan_set_security (uint8_t auth, const char *key, uint8_t len) {
@ -656,7 +655,7 @@ STATIC void wlan_set_security (uint8_t auth, const char *key, uint8_t len) {
STATIC void wlan_validate_channel (uint8_t channel) {
if (channel < 1 || channel > 11) {
mp_raise_ValueError(mpexception_value_invalid_arguments);
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
}
}
@ -668,7 +667,7 @@ STATIC void wlan_set_channel (uint8_t channel) {
#if MICROPY_HW_ANTENNA_DIVERSITY
STATIC void wlan_validate_antenna (uint8_t antenna) {
if (antenna != ANTENNA_TYPE_INTERNAL && antenna != ANTENNA_TYPE_EXTERNAL) {
mp_raise_ValueError(mpexception_value_invalid_arguments);
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
}
}
@ -964,7 +963,7 @@ STATIC mp_obj_t wlan_connect(size_t n_args, const mp_obj_t *pos_args, mp_map_t *
if (status == MODWLAN_ERROR_TIMEOUT) {
mp_raise_OSError(MP_ETIMEDOUT);
} else if (status == MODWLAN_ERROR_INVALID_PARAMS) {
mp_raise_ValueError(mpexception_value_invalid_arguments);
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
}
return mp_const_none;
}
@ -1040,7 +1039,7 @@ STATIC mp_obj_t wlan_ifconfig(size_t n_args, const mp_obj_t *pos_args, mp_map_t
// check for the correct string
const char *mode = mp_obj_str_get_str(args[1].u_obj);
if (strcmp("dhcp", mode)) {
mp_raise_ValueError(mpexception_value_invalid_arguments);
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
}
// only if we are not in AP mode
@ -1154,7 +1153,7 @@ STATIC mp_obj_t wlan_mac(size_t n_args, const mp_obj_t *args) {
mp_buffer_info_t bufinfo;
mp_get_buffer_raise(args[1], &bufinfo, MP_BUFFER_READ);
if (bufinfo.len != 6) {
mp_raise_ValueError(mpexception_value_invalid_arguments);
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
}
memcpy(self->mac, bufinfo.buf, SL_MAC_ADDR_LEN);
sl_NetCfgSet(SL_MAC_ADDRESS_SET, 1, SL_MAC_ADDR_LEN, (_u8 *)self->mac);
@ -1190,7 +1189,7 @@ STATIC mp_obj_t wlan_irq(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_a
return _irq;
invalid_args:
mp_raise_ValueError(mpexception_value_invalid_arguments);
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
}
STATIC MP_DEFINE_CONST_FUN_OBJ_KW(wlan_irq_obj, 1, wlan_irq);
@ -1219,7 +1218,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_KW(wlan_irq_obj, 1, wlan_irq);
//
// // the call to sl_NetAppSet corrupts the input string URN=args[1], so we copy into a local buffer
// if (len > MAX_DEVICE_URN_LEN) {
// mp_raise_ValueError(mpexception_value_invalid_arguments);
// mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
// }
// strcpy(urn, p);
//

9
ports/cc3200/mods/pybadc.c
Wyświetl plik

@ -47,7 +47,6 @@
#include "pybpin.h"
#include "pybsleep.h"
#include "pins.h"
#include "mpexception.h"
/******************************************************************************
@ -153,7 +152,7 @@ STATIC mp_obj_t adc_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_
// check the number of bits
if (args[1].u_int != 12) {
mp_raise_ValueError(mpexception_value_invalid_arguments);
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
}
// setup the object
@ -172,7 +171,7 @@ STATIC mp_obj_t adc_init(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_a
mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(args), &pyb_adc_init_args[1], args);
// check the number of bits
if (args[0].u_int != 12) {
mp_raise_ValueError(mpexception_value_invalid_arguments);
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
}
pyb_adc_init(pos_args[0]);
return mp_const_none;
@ -205,11 +204,11 @@ STATIC mp_obj_t adc_channel(size_t n_args, const mp_obj_t *pos_args, mp_map_t *k
if (args[0].u_obj != MP_OBJ_NULL) {
ch_id = mp_obj_get_int(args[0].u_obj);
if (ch_id >= PYB_ADC_NUM_CHANNELS) {
mp_raise_ValueError(mpexception_value_invalid_arguments);
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
} else if (args[1].u_obj != mp_const_none) {
uint pin_ch_id = pin_find_peripheral_type (args[1].u_obj, PIN_FN_ADC, 0);
if (ch_id != pin_ch_id) {
mp_raise_ValueError(mpexception_value_invalid_arguments);
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
}
}
} else {

1
ports/cc3200/mods/pybi2c.c
Wyświetl plik

@ -41,7 +41,6 @@
#include "prcm.h"
#include "i2c.h"
#include "pybi2c.h"
#include "mpexception.h"
#include "pybsleep.h"
#include "utils.h"
#include "pybpin.h"

21
ports/cc3200/mods/pybpin.c
Wyświetl plik

@ -44,7 +44,6 @@
#include "mpirq.h"
#include "pins.h"
#include "pybsleep.h"
#include "mpexception.h"
#include "mperror.h"
@ -142,7 +141,7 @@ pin_obj_t *pin_find(mp_obj_t user_obj) {
return pin_obj;
}
mp_raise_ValueError(mpexception_value_invalid_arguments);
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
}
void pin_config (pin_obj_t *self, int af, uint mode, uint pull, int value, uint strength) {
@ -182,7 +181,7 @@ uint8_t pin_find_peripheral_unit (const mp_obj_t pin, uint8_t fn, uint8_t type)
return pin_o->af_list[i].unit;
}
}
mp_raise_ValueError(mpexception_value_invalid_arguments);
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
}
uint8_t pin_find_peripheral_type (const mp_obj_t pin, uint8_t fn, uint8_t unit) {
@ -192,13 +191,13 @@ uint8_t pin_find_peripheral_type (const mp_obj_t pin, uint8_t fn, uint8_t unit)
return pin_o->af_list[i].type;
}
}
mp_raise_ValueError(mpexception_value_invalid_arguments);
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
}
int8_t pin_find_af_index (const pin_obj_t* pin, uint8_t fn, uint8_t unit, uint8_t type) {
int8_t af = pin_obj_find_af(pin, fn, unit, type);
if (af < 0) {
mp_raise_ValueError(mpexception_value_invalid_arguments);
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
}
return af;
}
@ -423,18 +422,18 @@ STATIC void pin_extint_register(pin_obj_t *self, uint32_t intmode, uint32_t prio
STATIC void pin_validate_mode (uint mode) {
if (mode != GPIO_DIR_MODE_IN && mode != GPIO_DIR_MODE_OUT && mode != PIN_TYPE_OD &&
mode != GPIO_DIR_MODE_ALT && mode != GPIO_DIR_MODE_ALT_OD) {
mp_raise_ValueError(mpexception_value_invalid_arguments);
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
}
}
STATIC void pin_validate_pull (uint pull) {
if (pull != PIN_TYPE_STD && pull != PIN_TYPE_STD_PU && pull != PIN_TYPE_STD_PD) {
mp_raise_ValueError(mpexception_value_invalid_arguments);
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
}
}
STATIC void pin_validate_drive(uint strength) {
if (strength != PIN_STRENGTH_2MA && strength != PIN_STRENGTH_4MA && strength != PIN_STRENGTH_6MA) {
mp_raise_ValueError(mpexception_value_invalid_arguments);
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
}
}
@ -447,7 +446,7 @@ STATIC void pin_validate_af(const pin_obj_t* pin, int8_t idx, uint8_t *fn, uint8
return;
}
}
mp_raise_ValueError(mpexception_value_invalid_arguments);
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
}
STATIC uint8_t pin_get_value (const pin_obj_t* self) {
@ -588,7 +587,7 @@ STATIC mp_obj_t pin_obj_init_helper(pin_obj_t *self, size_t n_args, const mp_obj
return mp_const_none;
invalid_args:
mp_raise_ValueError(mpexception_value_invalid_arguments);
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
}
STATIC void pin_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
@ -895,7 +894,7 @@ STATIC mp_obj_t pin_irq(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_ar
return _irq;
invalid_args:
mp_raise_ValueError(mpexception_value_invalid_arguments);
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
}
STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pin_irq_obj, 1, pin_irq);

7
ports/cc3200/mods/pybrtc.c
Wyświetl plik

@ -41,7 +41,6 @@
#include "simplelink.h"
#include "modnetwork.h"
#include "modwlan.h"
#include "mpexception.h"
/// \moduleref pyb
/// \class RTC - real time clock
@ -201,7 +200,7 @@ STATIC uint pyb_rtc_datetime_s_us(const mp_obj_t datetime, uint32_t *seconds) {
// verify the tuple
if (len < 3 || len > 8) {
mp_raise_ValueError(mpexception_value_invalid_arguments);
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
}
tm.tm_year = mp_obj_get_int(items[0]);
@ -370,7 +369,7 @@ STATIC mp_obj_t pyb_rtc_alarm(size_t n_args, const mp_obj_t *pos_args, mp_map_t
if (mp_obj_is_type(args[1].u_obj, &mp_type_tuple)) { // datetime tuple given
// repeat cannot be used with a datetime tuple
if (repeat) {
mp_raise_ValueError(mpexception_value_invalid_arguments);
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
}
f_mseconds = pyb_rtc_datetime_s_us (args[1].u_obj, &f_seconds) / 1000;
} else { // then it must be an integer
@ -452,7 +451,7 @@ STATIC mp_obj_t pyb_rtc_irq(size_t n_args, const mp_obj_t *pos_args, mp_map_t *k
return _irq;
invalid_args:
mp_raise_ValueError(mpexception_value_invalid_arguments);
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
}
STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_rtc_irq_obj, 1, pyb_rtc_irq);

1
ports/cc3200/mods/pybsd.c
Wyświetl plik

@ -42,7 +42,6 @@
#include "sdhost.h"
#include "sd_diskio.h"
#include "pybsd.h"
#include "mpexception.h"
#include "pybsleep.h"
#include "pybpin.h"
#include "pins.h"

1
ports/cc3200/mods/pybsleep.c
Wyświetl plik

@ -49,7 +49,6 @@
#include "modwlan.h"
#include "osi.h"
#include "debug.h"
#include "mpexception.h"
#include "mperror.h"
#include "sleeprestore.h"
#include "serverstask.h"

5
ports/cc3200/mods/pybspi.c
Wyświetl plik

@ -40,7 +40,6 @@
#include "prcm.h"
#include "spi.h"
#include "pybspi.h"
#include "mpexception.h"
#include "pybsleep.h"
#include "pybpin.h"
#include "pins.h"
@ -213,7 +212,7 @@ STATIC mp_obj_t pyb_spi_init_helper(pyb_spi_obj_t *self, const mp_arg_val_t *arg
return mp_const_none;
invalid_args:
mp_raise_ValueError(mpexception_value_invalid_arguments);
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
}
static const mp_arg_t pyb_spi_init_args[] = {
@ -351,7 +350,7 @@ STATIC mp_obj_t pyb_spi_write_readinto (mp_obj_t self, mp_obj_t writebuf, mp_obj
// get the read buffer
mp_get_buffer_raise(readbuf, &bufinfo_read, MP_BUFFER_WRITE);
if (bufinfo_read.len != bufinfo_write.len) {
mp_raise_ValueError(mpexception_value_invalid_arguments);
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
}
}

13
ports/cc3200/mods/pybtimer.c
Wyświetl plik

@ -47,7 +47,6 @@
#include "pins.h"
#include "mpirq.h"
#include "pybsleep.h"
#include "mpexception.h"
/// \moduleref pyb
@ -221,7 +220,7 @@ STATIC uint32_t compute_prescaler_period_and_match_value(pyb_timer_channel_obj_t
return prescaler;
error:
mp_raise_ValueError(mpexception_value_invalid_arguments);
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
}
STATIC void timer_init (pyb_timer_obj_t *tim) {
@ -317,7 +316,7 @@ STATIC mp_obj_t pyb_timer_init_helper(pyb_timer_obj_t *tim, size_t n_args, const
return mp_const_none;
error:
mp_raise_ValueError(mpexception_value_invalid_arguments);
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
}
STATIC mp_obj_t pyb_timer_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
@ -438,7 +437,7 @@ STATIC mp_obj_t pyb_timer_channel(size_t n_args, const mp_obj_t *pos_args, mp_ma
return ch;
error:
mp_raise_ValueError(mpexception_value_invalid_arguments);
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
}
STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_timer_channel_obj, 2, pyb_timer_channel);
@ -558,7 +557,7 @@ STATIC mp_obj_t pyb_timer_channel_freq(size_t n_args, const mp_obj_t *args) {
// set
int32_t _frequency = mp_obj_get_int(args[1]);
if (_frequency <= 0) {
mp_raise_ValueError(mpexception_value_invalid_arguments);
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
}
ch->frequency = _frequency;
ch->period = 1000000 / _frequency;
@ -577,7 +576,7 @@ STATIC mp_obj_t pyb_timer_channel_period(size_t n_args, const mp_obj_t *args) {
// set
int32_t _period = mp_obj_get_int(args[1]);
if (_period <= 0) {
mp_raise_ValueError(mpexception_value_invalid_arguments);
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
}
ch->period = _period;
ch->frequency = 1000000 / _period;
@ -710,7 +709,7 @@ STATIC mp_obj_t pyb_timer_channel_irq(size_t n_args, const mp_obj_t *pos_args, m
return _irq;
invalid_args:
mp_raise_ValueError(mpexception_value_invalid_arguments);
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
}
STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_timer_channel_irq_obj, 1, pyb_timer_channel_irq);

5
ports/cc3200/mods/pybuart.c
Wyświetl plik

@ -45,7 +45,6 @@
#include "pybuart.h"
#include "mpirq.h"
#include "pybsleep.h"
#include "mpexception.h"
#include "osi.h"
#include "utils.h"
#include "pin.h"
@ -431,7 +430,7 @@ STATIC mp_obj_t pyb_uart_init_helper(pyb_uart_obj_t *self, const mp_arg_val_t *a
return mp_const_none;
error:
mp_raise_ValueError(mpexception_value_invalid_arguments);
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
}
STATIC const mp_arg_t pyb_uart_init_args[] = {
@ -555,7 +554,7 @@ STATIC mp_obj_t pyb_uart_irq(size_t n_args, const mp_obj_t *pos_args, mp_map_t *
return uart_irq_new (self, trigger, priority, args[2].u_obj);
invalid_args:
mp_raise_ValueError(mpexception_value_invalid_arguments);
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
}
STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_uart_irq_obj, 1, pyb_uart_irq);

3
ports/cc3200/mods/pybwdt.c
Wyświetl plik

@ -40,7 +40,6 @@
#include "prcm.h"
#include "utils.h"
#include "pybwdt.h"
#include "mpexception.h"
#include "mperror.h"
@ -105,7 +104,7 @@ STATIC mp_obj_t pyb_wdt_make_new(const mp_obj_type_t *type, size_t n_args, size_
}
uint timeout_ms = args[1].u_int;
if (timeout_ms < PYBWDT_MIN_TIMEOUT_MS) {
mp_raise_ValueError(mpexception_value_invalid_arguments);
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
}
if (pyb_wdt_obj.running) {
mp_raise_OSError(MP_EPERM);

2
ports/cc3200/mpthreadport.c
Wyświetl plik

@ -132,7 +132,7 @@ void mp_thread_create(void *(*entry)(void *), void *arg, size_t *stack_size) {
TaskHandle_t id = xTaskCreateStatic(freertos_entry, "Thread", *stack_size / sizeof(void *), arg, 2, stack, tcb);
if (id == NULL) {
mp_thread_mutex_unlock(&thread_mutex);
mp_raise_msg(&mp_type_OSError, "can't create thread");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("can't create thread"));
}
// add thread to linked list of all threads

5
ports/cc3200/serverstask.c
Wyświetl plik

@ -38,7 +38,6 @@
#include "ftp.h"
#include "pybwdt.h"
#include "modusocket.h"
#include "mpexception.h"
#include "modnetwork.h"
#include "modwlan.h"
@ -184,7 +183,7 @@ void servers_close_socket (int16_t *sd) {
void servers_set_login (char *user, char *pass) {
if (strlen(user) > SERVERS_USER_PASS_LEN_MAX || strlen(pass) > SERVERS_USER_PASS_LEN_MAX) {
mp_raise_ValueError(mpexception_value_invalid_arguments);
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
}
memcpy(servers_user, user, SERVERS_USER_PASS_LEN_MAX);
memcpy(servers_pass, pass, SERVERS_USER_PASS_LEN_MAX);
@ -193,7 +192,7 @@ void servers_set_login (char *user, char *pass) {
void servers_set_timeout (uint32_t timeout) {
if (timeout < SERVERS_MIN_TIMEOUT_MS) {
// timeout is too low
mp_raise_ValueError(mpexception_value_invalid_arguments);
mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
}
servers_data.timeout = timeout;
}

1
ports/cc3200/telnet/telnet.c
Wyświetl plik

@ -35,7 +35,6 @@
#include "modwlan.h"
#include "modusocket.h"
#include "debug.h"
#include "mpexception.h"
#include "serverstask.h"
#include "genhdr/mpversion.h"
#include "irq.h"

6
ports/esp32/esp32_rmt.c
Wyświetl plik

@ -61,7 +61,7 @@ typedef struct _esp32_rmt_obj_t {
// At least update the method in machine_time.c.
STATIC esp_err_t check_esp_err(esp_err_t code) {
if (code) {
mp_raise_msg(&mp_type_OSError, esp_err_to_name(code));
mp_raise_msg(&mp_type_OSError, (mp_rom_error_text_t)esp_err_to_name(code));
}
return code;
@ -80,7 +80,7 @@ STATIC mp_obj_t esp32_rmt_make_new(const mp_obj_type_t *type, size_t n_args, siz
mp_uint_t clock_div = args[2].u_int;
if (clock_div < 1 || clock_div > 255) {
mp_raise_ValueError("clock_div must be between 1 and 255");
mp_raise_ValueError(MP_ERROR_TEXT("clock_div must be between 1 and 255"));
}
esp32_rmt_obj_t *self = m_new_obj_with_finaliser(esp32_rmt_obj_t);
@ -189,7 +189,7 @@ STATIC mp_obj_t esp32_rmt_write_pulses(size_t n_args, const mp_obj_t *pos_args,
mp_uint_t start = args[2].u_int;
if (start < 0 || start > 1) {
mp_raise_ValueError("start must be 0 or 1");
mp_raise_ValueError(MP_ERROR_TEXT("start must be 0 or 1"));
}
size_t pulses_length = 0;

10
ports/esp32/machine_adc.c
Wyświetl plik

@ -75,13 +75,13 @@ STATIC mp_obj_t madc_make_new(const mp_obj_type_t *type, size_t n_args, size_t n
}
}
if (!self) {
mp_raise_ValueError("invalid Pin for ADC");
mp_raise_ValueError(MP_ERROR_TEXT("invalid Pin for ADC"));
}
esp_err_t err = adc1_config_channel_atten(self->adc1_id, ADC_ATTEN_0db);
if (err == ESP_OK) {
return MP_OBJ_FROM_PTR(self);
}
mp_raise_ValueError("Parameter Error");
mp_raise_ValueError(MP_ERROR_TEXT("Parameter Error"));
}
STATIC void madc_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
@ -104,7 +104,7 @@ STATIC mp_obj_t madc_read(mp_obj_t self_in) {
madc_obj_t *self = self_in;
int val = adc1_get_raw(self->adc1_id);
if (val == -1) {
mp_raise_ValueError("Parameter Error");
mp_raise_ValueError(MP_ERROR_TEXT("Parameter Error"));
}
return MP_OBJ_NEW_SMALL_INT(val);
}
@ -117,7 +117,7 @@ STATIC mp_obj_t madc_atten(mp_obj_t self_in, mp_obj_t atten_in) {
if (err == ESP_OK) {
return mp_const_none;
}
mp_raise_ValueError("Parameter Error");
mp_raise_ValueError(MP_ERROR_TEXT("Parameter Error"));
}
MP_DEFINE_CONST_FUN_OBJ_2(madc_atten_obj, madc_atten);
@ -125,7 +125,7 @@ STATIC mp_obj_t madc_width(mp_obj_t cls_in, mp_obj_t width_in) {
adc_bits_width_t width = mp_obj_get_int(width_in);
esp_err_t err = adc1_config_width(width);
if (err != ESP_OK) {
mp_raise_ValueError("Parameter Error");
mp_raise_ValueError(MP_ERROR_TEXT("Parameter Error"));
}
switch (width) {
case ADC_WIDTH_9Bit:

8
ports/esp32/machine_dac.c
Wyświetl plik

@ -60,7 +60,7 @@ STATIC mp_obj_t mdac_make_new(const mp_obj_type_t *type, size_t n_args, size_t n
}
}
if (!self) {
mp_raise_ValueError("invalid Pin for DAC");
mp_raise_ValueError(MP_ERROR_TEXT("invalid Pin for DAC"));
}
esp_err_t err = dac_output_enable(self->dac_id);
@ -70,7 +70,7 @@ STATIC mp_obj_t mdac_make_new(const mp_obj_type_t *type, size_t n_args, size_t n
if (err == ESP_OK) {
return MP_OBJ_FROM_PTR(self);
}
mp_raise_ValueError("Parameter Error");
mp_raise_ValueError(MP_ERROR_TEXT("Parameter Error"));
}
STATIC void mdac_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
@ -82,14 +82,14 @@ STATIC mp_obj_t mdac_write(mp_obj_t self_in, mp_obj_t value_in) {
mdac_obj_t *self = self_in;
int value = mp_obj_get_int(value_in);
if (value < 0 || value > 255) {
mp_raise_ValueError("Value out of range");
mp_raise_ValueError(MP_ERROR_TEXT("Value out of range"));
}
esp_err_t err = dac_output_voltage(self->dac_id, value);
if (err == ESP_OK) {
return mp_const_none;
}
mp_raise_ValueError("Parameter Error");
mp_raise_ValueError(MP_ERROR_TEXT("Parameter Error"));
}
MP_DEFINE_CONST_FUN_OBJ_2(mdac_write_obj, mdac_write);

22
ports/esp32/machine_hw_spi.c
Wyświetl plik

@ -64,21 +64,21 @@ STATIC machine_hw_spi_obj_t machine_hw_spi_obj[2];
STATIC void machine_hw_spi_deinit_internal(machine_hw_spi_obj_t *self) {
switch (spi_bus_remove_device(self->spi)) {
case ESP_ERR_INVALID_ARG:
mp_raise_msg(&mp_type_OSError, "invalid configuration");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("invalid configuration"));
return;
case ESP_ERR_INVALID_STATE:
mp_raise_msg(&mp_type_OSError, "SPI device already freed");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("SPI device already freed"));
return;
}
switch (spi_bus_free(self->host)) {
case ESP_ERR_INVALID_ARG:
mp_raise_msg(&mp_type_OSError, "invalid configuration");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("invalid configuration"));
return;
case ESP_ERR_INVALID_STATE:
mp_raise_msg(&mp_type_OSError, "SPI bus already freed");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("SPI bus already freed"));
return;
}
@ -159,7 +159,7 @@ STATIC void machine_hw_spi_init_internal(
}
if (self->host != HSPI_HOST && self->host != VSPI_HOST) {
mp_raise_ValueError("SPI ID must be either HSPI(1) or VSPI(2)");
mp_raise_ValueError(MP_ERROR_TEXT("SPI ID must be either HSPI(1) or VSPI(2)"));
}
if (changed) {
@ -201,28 +201,28 @@ STATIC void machine_hw_spi_init_internal(
ret = spi_bus_initialize(self->host, &buscfg, dma_chan);
switch (ret) {
case ESP_ERR_INVALID_ARG:
mp_raise_msg(&mp_type_OSError, "invalid configuration");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("invalid configuration"));
return;
case ESP_ERR_INVALID_STATE:
mp_raise_msg(&mp_type_OSError, "SPI host already in use");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("SPI host already in use"));
return;
}
ret = spi_bus_add_device(self->host, &devcfg, &self->spi);
switch (ret) {
case ESP_ERR_INVALID_ARG:
mp_raise_msg(&mp_type_OSError, "invalid configuration");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("invalid configuration"));
spi_bus_free(self->host);
return;
case ESP_ERR_NO_MEM:
mp_raise_msg(&mp_type_OSError, "out of memory");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("out of memory"));
spi_bus_free(self->host);
return;
case ESP_ERR_NOT_FOUND:
mp_raise_msg(&mp_type_OSError, "no free slots");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("no free slots"));
spi_bus_free(self->host);
return;
}
@ -241,7 +241,7 @@ STATIC void machine_hw_spi_transfer(mp_obj_base_t *self_in, size_t len, const ui
machine_hw_spi_obj_t *self = MP_OBJ_TO_PTR(self_in);
if (self->state == MACHINE_HW_SPI_STATE_DEINIT) {
mp_raise_msg(&mp_type_OSError, "transfer on deinitialized SPI");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("transfer on deinitialized SPI"));
return;
}

2
ports/esp32/machine_i2c.c
Wyświetl plik

@ -130,7 +130,7 @@ mp_obj_t machine_hw_i2c_make_new(const mp_obj_type_t *type, size_t n_args, size_
// Get I2C bus
mp_int_t i2c_id = mp_obj_get_int(args[ARG_id].u_obj);
if (!(I2C_NUM_0 <= i2c_id && i2c_id < I2C_NUM_MAX)) {
mp_raise_msg_varg(&mp_type_ValueError, "I2C(%d) doesn't exist", i2c_id);
mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("I2C(%d) doesn't exist"), i2c_id);
}
// Get static peripheral object

16
ports/esp32/machine_pin.c
Wyświetl plik

@ -126,7 +126,7 @@ STATIC void machine_pin_isr_handler(void *arg) {
gpio_num_t machine_pin_get_id(mp_obj_t pin_in) {
if (mp_obj_get_type(pin_in) != &machine_pin_type) {
mp_raise_ValueError("expecting a pin");
mp_raise_ValueError(MP_ERROR_TEXT("expecting a pin"));
}
machine_pin_obj_t *self = pin_in;
return self->id;
@ -162,7 +162,7 @@ STATIC mp_obj_t machine_pin_obj_init_helper(const machine_pin_obj_t *self, size_
if (args[ARG_mode].u_obj != mp_const_none) {
mp_int_t pin_io_mode = mp_obj_get_int(args[ARG_mode].u_obj);
if (self->id >= 34 && (pin_io_mode & GPIO_MODE_DEF_OUTPUT)) {
mp_raise_ValueError("pin can only be input");
mp_raise_ValueError(MP_ERROR_TEXT("pin can only be input"));
} else {
gpio_set_direction(self->id, pin_io_mode);
}
@ -205,7 +205,7 @@ mp_obj_t mp_pin_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw,
self = (machine_pin_obj_t *)&machine_pin_obj[wanted_pin];
}
if (self == NULL || self->base.type == NULL) {
mp_raise_ValueError("invalid pin");
mp_raise_ValueError(MP_ERROR_TEXT("invalid pin"));
}
if (n_args > 1 || n_kw > 0) {
@ -282,24 +282,24 @@ STATIC mp_obj_t machine_pin_irq(size_t n_args, const mp_obj_t *pos_args, mp_map_
mp_int_t wake;
if (mp_obj_get_int_maybe(wake_obj, &wake)) {
if (wake < 2 || wake > 7) {
mp_raise_ValueError("bad wake value");
mp_raise_ValueError(MP_ERROR_TEXT("bad wake value"));
}
} else {
mp_raise_ValueError("bad wake value");
mp_raise_ValueError(MP_ERROR_TEXT("bad wake value"));
}
if (machine_rtc_config.wake_on_touch) { // not compatible
mp_raise_ValueError("no resources");
mp_raise_ValueError(MP_ERROR_TEXT("no resources"));
}
if (!RTC_IS_VALID_EXT_PIN(self->id)) {
mp_raise_ValueError("invalid pin for wake");
mp_raise_ValueError(MP_ERROR_TEXT("invalid pin for wake"));
}
if (machine_rtc_config.ext0_pin == -1) {
machine_rtc_config.ext0_pin = self->id;
} else if (machine_rtc_config.ext0_pin != self->id) {
mp_raise_ValueError("no resources");
mp_raise_ValueError(MP_ERROR_TEXT("no resources"));
}
machine_rtc_config.ext0_level = trigger == GPIO_PIN_INTR_LOLEVEL ? 0 : 1;

8
ports/esp32/machine_pwm.c
Wyświetl plik

@ -145,7 +145,7 @@ STATIC void esp32_pwm_init_helper(esp32_pwm_obj_t *self,
}
if (channel >= LEDC_CHANNEL_MAX) {
if (avail == -1) {
mp_raise_ValueError("out of PWM channels");
mp_raise_ValueError(MP_ERROR_TEXT("out of PWM channels"));
}
channel = avail;
}
@ -163,7 +163,7 @@ STATIC void esp32_pwm_init_helper(esp32_pwm_obj_t *self,
.timer_sel = PWTIMER,
};
if (ledc_channel_config(&cfg) != ESP_OK) {
mp_raise_msg_varg(&mp_type_ValueError, "PWM not supported on pin %d", self->pin);
mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("PWM not supported on pin %d"), self->pin);
}
chan_gpio[channel] = self->pin;
}
@ -173,7 +173,7 @@ STATIC void esp32_pwm_init_helper(esp32_pwm_obj_t *self,
if (tval != -1) {
if (tval != timer_cfg.freq_hz) {
if (!set_freq(tval)) {
mp_raise_msg_varg(&mp_type_ValueError, "Bad frequency %d", tval);
mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("Bad frequency %d"), tval);
}
}
}
@ -247,7 +247,7 @@ STATIC mp_obj_t esp32_pwm_freq(size_t n_args, const mp_obj_t *args) {
// set
int tval = mp_obj_get_int(args[1]);
if (!set_freq(tval)) {
mp_raise_msg_varg(&mp_type_ValueError, "Bad frequency %d", tval);
mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("Bad frequency %d"), tval);
}
return mp_const_none;
}

2
ports/esp32/machine_rtc.c
Wyświetl plik

@ -154,7 +154,7 @@ STATIC mp_obj_t machine_rtc_memory(mp_uint_t n_args, const mp_obj_t *args) {
mp_get_buffer_raise(args[1], &bufinfo, MP_BUFFER_READ);
if (bufinfo.len > MICROPY_HW_RTC_USER_MEM_MAX) {
mp_raise_ValueError("buffer too long");
mp_raise_ValueError(MP_ERROR_TEXT("buffer too long"));
}
memcpy((char *)rtc_user_mem_data, (char *)bufinfo.buf, bufinfo.len);
rtc_user_mem_len = bufinfo.len;

4
ports/esp32/machine_sdcard.c
Wyświetl plik

@ -177,7 +177,7 @@ STATIC mp_obj_t machine_sdcard_make_new(const mp_obj_type_t *type, size_t n_args
int slot_num = arg_vals[ARG_slot].u_int;
if (slot_num < 0 || slot_num > 3) {
mp_raise_ValueError("Slot number must be between 0 and 3 inclusive");
mp_raise_ValueError(MP_ERROR_TEXT("Slot number must be between 0 and 3 inclusive"));
}
// Slots 0 and 1 are native SD/MMC, slots 2 and 3 are SPI
@ -253,7 +253,7 @@ STATIC mp_obj_t machine_sdcard_make_new(const mp_obj_type_t *type, size_t n_args
if (width == 1 || width == 4 || (width == 8 && slot_num == 0)) {
slot_config.width = width;
} else {
mp_raise_ValueError("Width must be 1 or 4 (or 8 on slot 0)");
mp_raise_ValueError(MP_ERROR_TEXT("Width must be 1 or 4 (or 8 on slot 0)"));
}
DEBUG_printf(" Calling init_slot()");

8
ports/esp32/machine_touchpad.c
Wyświetl plik

@ -68,7 +68,7 @@ STATIC mp_obj_t mtp_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_
}
}
if (!self) {
mp_raise_ValueError("invalid pin for touchpad");
mp_raise_ValueError(MP_ERROR_TEXT("invalid pin for touchpad"));
}
static int initialized = 0;
@ -81,7 +81,7 @@ STATIC mp_obj_t mtp_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_
if (err == ESP_OK) {
return MP_OBJ_FROM_PTR(self);
}
mp_raise_ValueError("Touch pad error");
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) {
@ -91,7 +91,7 @@ STATIC mp_obj_t mtp_config(mp_obj_t self_in, mp_obj_t value_in) {
if (err == ESP_OK) {
return mp_const_none;
}
mp_raise_ValueError("Touch pad error");
mp_raise_ValueError(MP_ERROR_TEXT("Touch pad error"));
}
MP_DEFINE_CONST_FUN_OBJ_2(mtp_config_obj, mtp_config);
@ -102,7 +102,7 @@ STATIC mp_obj_t mtp_read(mp_obj_t self_in) {
if (err == ESP_OK) {
return MP_OBJ_NEW_SMALL_INT(value);
}
mp_raise_ValueError("Touch pad error");
mp_raise_ValueError(MP_ERROR_TEXT("Touch pad error"));
}
MP_DEFINE_CONST_FUN_OBJ_1(mtp_read_obj, mtp_read);

10
ports/esp32/machine_uart.c
Wyświetl plik

@ -187,7 +187,7 @@ STATIC void machine_uart_init_helper(machine_uart_obj_t *self, size_t n_args, co
self->bits = 8;
break;
default:
mp_raise_ValueError("invalid data bits");
mp_raise_ValueError(MP_ERROR_TEXT("invalid data bits"));
break;
}
@ -222,7 +222,7 @@ STATIC void machine_uart_init_helper(machine_uart_obj_t *self, size_t n_args, co
self->stop = 2;
break;
default:
mp_raise_ValueError("invalid stop bits");
mp_raise_ValueError(MP_ERROR_TEXT("invalid stop bits"));
break;
}
@ -239,7 +239,7 @@ STATIC void machine_uart_init_helper(machine_uart_obj_t *self, size_t n_args, co
// set line inversion
if (args[ARG_invert].u_int & ~UART_LINE_INV_MASK) {
mp_raise_ValueError("invalid inversion mask");
mp_raise_ValueError(MP_ERROR_TEXT("invalid inversion mask"));
}
self->invert = args[ARG_invert].u_int;
uart_set_line_inverse(self->uart_num, self->invert);
@ -251,13 +251,13 @@ STATIC mp_obj_t machine_uart_make_new(const mp_obj_type_t *type, size_t n_args,
// 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, "UART(%d) does not exist", uart_num);
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, "UART(%d) is disabled (dedicated to REPL)", uart_num);
mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("UART(%d) is disabled (dedicated to REPL)"), uart_num);
}
// Defaults

2
ports/esp32/machine_wdt.c
Wyświetl plik

@ -58,7 +58,7 @@ STATIC mp_obj_t machine_wdt_make_new(const mp_obj_type_t *type_in, size_t n_args
args[ARG_timeout].u_int /= 1000;
if (args[ARG_timeout].u_int <= 0) {
mp_raise_ValueError("WDT timeout too short");
mp_raise_ValueError(MP_ERROR_TEXT("WDT timeout too short"));
}
mp_int_t rs_code = esp_task_wdt_init(args[ARG_timeout].u_int, true);

10
ports/esp32/modesp32.c
Wyświetl plik

@ -46,9 +46,9 @@
STATIC mp_obj_t esp32_wake_on_touch(const mp_obj_t wake) {
if (machine_rtc_config.ext0_pin != -1) {
mp_raise_ValueError("no resources");
mp_raise_ValueError(MP_ERROR_TEXT("no resources"));
}
//mp_raise_msg(&mp_type_RuntimeError, "touchpad wakeup not available for this version of ESP-IDF");
//mp_raise_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("touchpad wakeup not available for this version of ESP-IDF"));
machine_rtc_config.wake_on_touch = mp_obj_is_true(wake);
return mp_const_none;
@ -58,7 +58,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(esp32_wake_on_touch_obj, esp32_wake_on_touch);
STATIC mp_obj_t esp32_wake_on_ext0(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
if (machine_rtc_config.wake_on_touch) {
mp_raise_ValueError("no resources");
mp_raise_ValueError(MP_ERROR_TEXT("no resources"));
}
enum {ARG_pin, ARG_level};
const mp_arg_t allowed_args[] = {
@ -74,7 +74,7 @@ STATIC mp_obj_t esp32_wake_on_ext0(size_t n_args, const mp_obj_t *pos_args, mp_m
gpio_num_t pin_id = machine_pin_get_id(args[ARG_pin].u_obj);
if (pin_id != machine_rtc_config.ext0_pin) {
if (!RTC_IS_VALID_EXT_PIN(pin_id)) {
mp_raise_ValueError("invalid pin");
mp_raise_ValueError(MP_ERROR_TEXT("invalid pin"));
}
machine_rtc_config.ext0_pin = pin_id;
}
@ -109,7 +109,7 @@ STATIC mp_obj_t esp32_wake_on_ext1(size_t n_args, const mp_obj_t *pos_args, mp_m
gpio_num_t pin_id = machine_pin_get_id(elem[i]);
if (!RTC_IS_VALID_EXT_PIN(pin_id)) {
mp_raise_ValueError("invalid pin");
mp_raise_ValueError(MP_ERROR_TEXT("invalid pin"));
break;
}
ext1_pins |= (1ll << pin_id);

4
ports/esp32/modmachine.c
Wyświetl plik

@ -73,7 +73,7 @@ STATIC mp_obj_t machine_freq(size_t n_args, const mp_obj_t *args) {
// set
mp_int_t freq = mp_obj_get_int(args[0]) / 1000000;
if (freq != 20 && freq != 40 && freq != 80 && freq != 160 && freq != 240) {
mp_raise_ValueError("frequency must be 20MHz, 40MHz, 80Mhz, 160MHz or 240MHz");
mp_raise_ValueError(MP_ERROR_TEXT("frequency must be 20MHz, 40MHz, 80Mhz, 160MHz or 240MHz"));
}
esp_pm_config_esp32_t pm;
pm.max_freq_mhz = freq;
@ -120,7 +120,7 @@ STATIC mp_obj_t machine_sleep_helper(wake_type_t wake_type, size_t n_args, const
if (machine_rtc_config.wake_on_touch) {
if (esp_sleep_enable_touchpad_wakeup() != ESP_OK) {
mp_raise_msg(&mp_type_RuntimeError, "esp_sleep_enable_touchpad_wakeup() failed");
mp_raise_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("esp_sleep_enable_touchpad_wakeup() failed"));
}
}

54
ports/esp32/modnetwork.c
Wyświetl plik

@ -60,45 +60,45 @@
NORETURN void _esp_exceptions(esp_err_t e) {
switch (e) {
case ESP_ERR_WIFI_NOT_INIT:
mp_raise_msg(&mp_type_OSError, "Wifi Not Initialized");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Not Initialized"));
case ESP_ERR_WIFI_NOT_STARTED:
mp_raise_msg(&mp_type_OSError, "Wifi Not Started");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Not Started"));
case ESP_ERR_WIFI_NOT_STOPPED:
mp_raise_msg(&mp_type_OSError, "Wifi Not Stopped");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Not Stopped"));
case ESP_ERR_WIFI_IF:
mp_raise_msg(&mp_type_OSError, "Wifi Invalid Interface");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Invalid Interface"));
case ESP_ERR_WIFI_MODE:
mp_raise_msg(&mp_type_OSError, "Wifi Invalid Mode");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Invalid Mode"));
case ESP_ERR_WIFI_STATE:
mp_raise_msg(&mp_type_OSError, "Wifi Internal State Error");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Internal State Error"));
case ESP_ERR_WIFI_CONN:
mp_raise_msg(&mp_type_OSError, "Wifi Internal Error");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Internal Error"));
case ESP_ERR_WIFI_NVS:
mp_raise_msg(&mp_type_OSError, "Wifi Internal NVS Error");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Internal NVS Error"));
case ESP_ERR_WIFI_MAC:
mp_raise_msg(&mp_type_OSError, "Wifi Invalid MAC Address");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Invalid MAC Address"));
case ESP_ERR_WIFI_SSID:
mp_raise_msg(&mp_type_OSError, "Wifi SSID Invalid");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi SSID Invalid"));
case ESP_ERR_WIFI_PASSWORD:
mp_raise_msg(&mp_type_OSError, "Wifi Invalid Password");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Invalid Password"));
case ESP_ERR_WIFI_TIMEOUT:
mp_raise_OSError(MP_ETIMEDOUT);
case ESP_ERR_WIFI_WAKE_FAIL:
mp_raise_msg(&mp_type_OSError, "Wifi Wakeup Failure");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Wakeup Failure"));
case ESP_ERR_WIFI_WOULD_BLOCK:
mp_raise_msg(&mp_type_OSError, "Wifi Would Block");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Would Block"));
case ESP_ERR_WIFI_NOT_CONNECT:
mp_raise_msg(&mp_type_OSError, "Wifi Not Connected");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Not Connected"));
case ESP_ERR_TCPIP_ADAPTER_INVALID_PARAMS:
mp_raise_msg(&mp_type_OSError, "TCP/IP Invalid Parameters");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("TCP/IP Invalid Parameters"));
case ESP_ERR_TCPIP_ADAPTER_IF_NOT_READY:
mp_raise_msg(&mp_type_OSError, "TCP/IP IF Not Ready");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("TCP/IP IF Not Ready"));
case ESP_ERR_TCPIP_ADAPTER_DHCPC_START_FAILED:
mp_raise_msg(&mp_type_OSError, "TCP/IP DHCP Client Start Failed");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("TCP/IP DHCP Client Start Failed"));
case ESP_ERR_TCPIP_ADAPTER_NO_MEM:
mp_raise_OSError(MP_ENOMEM);
default:
mp_raise_msg_varg(&mp_type_RuntimeError, "Wifi Unknown Error 0x%04x", e);
mp_raise_msg_varg(&mp_type_RuntimeError, MP_ERROR_TEXT("Wifi Unknown Error 0x%04x"), e);
}
}
@ -241,7 +241,7 @@ static esp_err_t event_handler(void *ctx, system_event_t *event) {
STATIC void require_if(mp_obj_t wlan_if, int if_no) {
wlan_if_obj_t *self = MP_OBJ_TO_PTR(wlan_if);
if (self->if_id != if_no) {
mp_raise_msg(&mp_type_OSError, if_no == WIFI_IF_STA ? "STA required" : "AP required");
mp_raise_msg(&mp_type_OSError, if_no == WIFI_IF_STA ? MP_ERROR_TEXT("STA required") : MP_ERROR_TEXT("AP required"));
}
}
@ -262,7 +262,7 @@ STATIC mp_obj_t get_wlan(size_t n_args, const mp_obj_t *args) {
} else if (idx == WIFI_IF_AP) {
return MP_OBJ_FROM_PTR(&wlan_ap_obj);
} else {
mp_raise_ValueError("invalid WLAN interface identifier");
mp_raise_ValueError(MP_ERROR_TEXT("invalid WLAN interface identifier"));
}
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(get_wlan_obj, 0, 1, get_wlan);
@ -429,7 +429,7 @@ STATIC mp_obj_t esp_status(size_t n_args, const mp_obj_t *args) {
return MP_OBJ_NEW_SMALL_INT(info.rssi);
}
default:
mp_raise_ValueError("unknown status param");
mp_raise_ValueError(MP_ERROR_TEXT("unknown status param"));
}
return mp_const_none;
@ -441,7 +441,7 @@ STATIC mp_obj_t esp_scan(mp_obj_t self_in) {
wifi_mode_t mode;
ESP_EXCEPTIONS(esp_wifi_get_mode(&mode));
if ((mode & WIFI_MODE_STA) == 0) {
mp_raise_msg(&mp_type_OSError, "STA must be active");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("STA must be active"));
}
mp_obj_t list = mp_obj_new_list(0, NULL);
@ -540,7 +540,7 @@ STATIC mp_obj_t esp_ifconfig(size_t n_args, const mp_obj_t *args) {
// check for the correct string
const char *mode = mp_obj_str_get_str(args[1]);
if ((self->if_id != WIFI_IF_STA && self->if_id != ESP_IF_ETH) || strcmp("dhcp", mode)) {
mp_raise_ValueError("invalid arguments");
mp_raise_ValueError(MP_ERROR_TEXT("invalid arguments"));
}
ESP_EXCEPTIONS(tcpip_adapter_dhcpc_start(self->if_id));
}
@ -552,7 +552,7 @@ MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(esp_ifconfig_obj, 1, 2, esp_ifconfig);
STATIC mp_obj_t esp_config(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs) {
if (n_args != 1 && kwargs->used != 0) {
mp_raise_TypeError("either pos or kw args are allowed");
mp_raise_TypeError(MP_ERROR_TEXT("either pos or kw args are allowed"));
}
wlan_if_obj_t *self = MP_OBJ_TO_PTR(args[0]);
@ -580,7 +580,7 @@ STATIC mp_obj_t esp_config(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs
mp_buffer_info_t bufinfo;
mp_get_buffer_raise(kwargs->table[i].value, &bufinfo, MP_BUFFER_READ);
if (bufinfo.len != 6) {
mp_raise_ValueError("invalid buffer length");
mp_raise_ValueError(MP_ERROR_TEXT("invalid buffer length"));
}
ESP_EXCEPTIONS(esp_wifi_set_mac(self->if_id, bufinfo.buf));
break;
@ -647,7 +647,7 @@ STATIC mp_obj_t esp_config(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs
// Get config
if (n_args != 2) {
mp_raise_TypeError("can query only one param");
mp_raise_TypeError(MP_ERROR_TEXT("can query only one param"));
}
int req_if = -1;
@ -720,7 +720,7 @@ STATIC mp_obj_t esp_config(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs
return val;
unknown:
mp_raise_ValueError("unknown config param");
mp_raise_ValueError(MP_ERROR_TEXT("unknown config param"));
}
MP_DEFINE_CONST_FUN_OBJ_KW(esp_config_obj, 1, esp_config);

2
ports/esp32/modutime.c
Wyświetl plik

@ -66,7 +66,7 @@ STATIC mp_obj_t time_mktime(mp_obj_t tuple) {
// 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, "mktime needs a tuple of length 8 or 9 (%d given)", len);
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]),

2
ports/esp32/mpthreadport.c
Wyświetl plik

@ -137,7 +137,7 @@ void mp_thread_create_ex(void *(*entry)(void *), void *arg, size_t *stack_size,
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, "can't create thread");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("can't create thread"));
}
// adjust the stack_size to provide room to recover from hitting the limit

14
ports/esp32/network_lan.c
Wyświetl plik

@ -111,7 +111,7 @@ STATIC mp_obj_t get_lan(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_ar
if (args[ARG_id].u_obj != mp_const_none) {
if (mp_obj_get_int(args[ARG_id].u_obj) != 0) {
mp_raise_ValueError("invalid LAN interface identifier");
mp_raise_ValueError(MP_ERROR_TEXT("invalid LAN interface identifier"));
}
}
@ -120,11 +120,11 @@ STATIC mp_obj_t get_lan(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_ar
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("invalid phy address");
mp_raise_ValueError(MP_ERROR_TEXT("invalid phy address"));
}
if (args[ARG_phy_type].u_int != PHY_LAN8720 && args[ARG_phy_type].u_int != PHY_TLK110) {
mp_raise_ValueError("invalid phy type");
mp_raise_ValueError(MP_ERROR_TEXT("invalid phy type"));
}
if (args[ARG_clock_mode].u_int != -1 &&
@ -133,7 +133,7 @@ STATIC mp_obj_t get_lan(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_ar
//args[ARG_clock_mode].u_int != ETH_CLOCK_GPIO0_OUT &&
args[ARG_clock_mode].u_int != ETH_CLOCK_GPIO16_OUT &&
args[ARG_clock_mode].u_int != ETH_CLOCK_GPIO17_OUT) {
mp_raise_ValueError("invalid clock mode");
mp_raise_ValueError(MP_ERROR_TEXT("invalid clock mode"));
}
eth_config_t config;
@ -165,7 +165,7 @@ STATIC mp_obj_t get_lan(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_ar
self->active = false;
self->initialized = true;
} else {
mp_raise_msg(&mp_type_OSError, "esp_eth_init() failed");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("esp_eth_init() failed"));
}
return MP_OBJ_FROM_PTR(&lan_obj);
}
@ -178,12 +178,12 @@ STATIC mp_obj_t lan_active(size_t n_args, const mp_obj_t *args) {
if (mp_obj_is_true(args[1])) {
self->active = (esp_eth_enable() == ESP_OK);
if (!self->active) {
mp_raise_msg(&mp_type_OSError, "ethernet enable failed");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("ethernet enable failed"));
}
} else {
self->active = !(esp_eth_disable() == ESP_OK);
if (self->active) {
mp_raise_msg(&mp_type_OSError, "ethernet disable failed");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("ethernet disable failed"));
}
}
}

12
ports/esp32/network_ppp.c
Wyświetl plik

@ -128,7 +128,7 @@ STATIC mp_obj_t ppp_active(size_t n_args, const mp_obj_t *args) {
self->pcb = pppapi_pppos_create(&self->pppif, ppp_output_callback, ppp_status_cb, self);
if (self->pcb == NULL) {
mp_raise_msg(&mp_type_RuntimeError, "init failed");
mp_raise_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("init failed"));
}
self->active = true;
} else {
@ -178,7 +178,7 @@ STATIC mp_obj_t ppp_connect_py(size_t n_args, const mp_obj_t *args, mp_map_t *kw
ppp_if_obj_t *self = MP_OBJ_TO_PTR(args[0]);
if (!self->active) {
mp_raise_msg(&mp_type_OSError, "must be active");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("must be active"));
}
if (self->client_task_handle != NULL) {
@ -191,7 +191,7 @@ STATIC mp_obj_t ppp_connect_py(size_t n_args, const mp_obj_t *args, mp_map_t *kw
case PPPAUTHTYPE_CHAP:
break;
default:
mp_raise_ValueError("invalid auth");
mp_raise_ValueError(MP_ERROR_TEXT("invalid auth"));
}
if (parsed_args[ARG_authmode].u_int != PPPAUTHTYPE_NONE) {
@ -200,17 +200,17 @@ STATIC mp_obj_t ppp_connect_py(size_t n_args, const mp_obj_t *args, mp_map_t *kw
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, "set default failed");
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, "connect failed");
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, "failed to create worker task");
mp_raise_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("failed to create worker task"));
}
return mp_const_none;

2
ports/esp8266/esp_mphal.c
Wyświetl plik

@ -149,7 +149,7 @@ void ets_event_poll(void) {
void __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, "C-level assert");
mp_raise_msg(&mp_type_AssertionError, MP_ERROR_TEXT("C-level assert"));
}
void mp_hal_signal_input(void) {

2
ports/esp8266/machine_adc.c
Wyświetl plik

@ -64,7 +64,7 @@ mp_obj_t machine_adc_make_new(const mp_obj_type_t *type_in, size_t n_args, size_
case 1:
return &machine_adc_vdd3;
default:
mp_raise_msg_varg(&mp_type_ValueError, "ADC(%d) doesn't exist", chn);
mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("ADC(%d) doesn't exist"), chn);
}
}

4
ports/esp8266/machine_hspi.c
Wyświetl plik

@ -127,13 +127,13 @@ STATIC void machine_hspi_init(mp_obj_base_t *self_in, size_t n_args, const mp_ob
spi_init_gpio(HSPI, SPI_CLK_80MHZ_NODIV);
spi_clock(HSPI, 0, 0);
} else if (self->baudrate > 40000000L) {
mp_raise_ValueError("impossible baudrate");
mp_raise_ValueError(MP_ERROR_TEXT("impossible baudrate"));
} else {
uint32_t divider = 40000000L / self->baudrate;
uint16_t prediv = MIN(divider, SPI_CLKDIV_PRE + 1);
uint16_t cntdiv = (divider / prediv) * 2; // cntdiv has to be even
if (cntdiv > SPI_CLKCNT_N + 1 || cntdiv == 0 || prediv == 0) {
mp_raise_ValueError("impossible baudrate");
mp_raise_ValueError(MP_ERROR_TEXT("impossible baudrate"));
}
self->baudrate = 80000000L / (prediv * cntdiv);
spi_init_gpio(HSPI, SPI_CLK_USE_DIV);

8
ports/esp8266/machine_pin.c
Wyświetl plik

@ -128,7 +128,7 @@ void pin_intr_handler(uint32_t status) {
pyb_pin_obj_t *mp_obj_get_pin_obj(mp_obj_t pin_in) {
if (mp_obj_get_type(pin_in) != &pyb_pin_type) {
mp_raise_ValueError("expecting a pin");
mp_raise_ValueError(MP_ERROR_TEXT("expecting a pin"));
}
pyb_pin_obj_t *self = pin_in;
return self;
@ -283,7 +283,7 @@ STATIC mp_obj_t pyb_pin_obj_init_helper(pyb_pin_obj_t *self, size_t n_args, cons
// only pull-down seems to be supported by the hardware, and
// we only expose pull-up behaviour in software
if (pull != GPIO_PULL_NONE) {
mp_raise_ValueError("Pin(16) doesn't support pull");
mp_raise_ValueError(MP_ERROR_TEXT("Pin(16) doesn't support pull"));
}
} else {
PIN_FUNC_SELECT(self->periph, self->func);
@ -322,7 +322,7 @@ mp_obj_t mp_pin_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw,
pin = (pyb_pin_obj_t *)&pyb_pin_obj[wanted_pin];
}
if (pin == NULL || pin->base.type == NULL) {
mp_raise_ValueError("invalid pin");
mp_raise_ValueError(MP_ERROR_TEXT("invalid pin"));
}
if (n_args > 1 || n_kw > 0) {
@ -388,7 +388,7 @@ STATIC mp_obj_t pyb_pin_irq(size_t n_args, const mp_obj_t *pos_args, mp_map_t *k
mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
if (self->phys_port >= 16) {
mp_raise_msg(&mp_type_OSError, "pin does not have IRQ capabilities");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("pin does not have IRQ capabilities"));
}
if (n_args > 1 || kw_args->used != 0) {

2
ports/esp8266/machine_pwm.c
Wyświetl plik

@ -65,7 +65,7 @@ STATIC void pyb_pwm_init_helper(pyb_pwm_obj_t *self, size_t n_args, const mp_obj
int channel = pwm_add(self->pin->phys_port, self->pin->periph, self->pin->func);
if (channel == -1) {
mp_raise_msg_varg(&mp_type_ValueError, "PWM not supported on pin %d", self->pin->phys_port);
mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("PWM not supported on pin %d"), self->pin->phys_port);
}
self->channel = channel;

8
ports/esp8266/machine_rtc.c
Wyświetl plik

@ -181,7 +181,7 @@ STATIC mp_obj_t pyb_rtc_memory(size_t n_args, const mp_obj_t *args) {
mp_get_buffer_raise(args[1], &bufinfo, MP_BUFFER_READ);
if (bufinfo.len > MEM_USER_MAXLEN) {
mp_raise_ValueError("buffer too long");
mp_raise_ValueError(MP_ERROR_TEXT("buffer too long"));
}
len = bufinfo.len;
@ -205,7 +205,7 @@ STATIC mp_obj_t pyb_rtc_alarm(mp_obj_t self_in, mp_obj_t alarm_id, mp_obj_t time
// check we want alarm0
if (mp_obj_get_int(alarm_id) != 0) {
mp_raise_ValueError("invalid alarm");
mp_raise_ValueError(MP_ERROR_TEXT("invalid alarm"));
}
// set expiry time (in microseconds)
@ -219,7 +219,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_3(pyb_rtc_alarm_obj, pyb_rtc_alarm);
STATIC mp_obj_t pyb_rtc_alarm_left(size_t n_args, const mp_obj_t *args) {
// check we want alarm0
if (n_args > 1 && mp_obj_get_int(args[1]) != 0) {
mp_raise_ValueError("invalid alarm");
mp_raise_ValueError(MP_ERROR_TEXT("invalid alarm"));
}
uint64_t now = pyb_rtc_get_us_since_2000();
@ -242,7 +242,7 @@ STATIC mp_obj_t pyb_rtc_irq(size_t n_args, const mp_obj_t *pos_args, mp_map_t *k
// check we want alarm0
if (args[ARG_trigger].u_int != 0) {
mp_raise_ValueError("invalid alarm");
mp_raise_ValueError(MP_ERROR_TEXT("invalid alarm"));
}
// set the wake value

10
ports/esp8266/machine_uart.c
Wyświetl plik

@ -107,7 +107,7 @@ STATIC void pyb_uart_init_helper(pyb_uart_obj_t *self, size_t n_args, const mp_o
self->bits = 8;
break;
default:
mp_raise_ValueError("invalid data bits");
mp_raise_ValueError(MP_ERROR_TEXT("invalid data bits"));
break;
}
@ -143,7 +143,7 @@ STATIC void pyb_uart_init_helper(pyb_uart_obj_t *self, size_t n_args, const mp_o
} else if (tx == 15 && rx == 13) {
system_uart_swap();
} else {
mp_raise_ValueError("invalid tx/rx");
mp_raise_ValueError(MP_ERROR_TEXT("invalid tx/rx"));
}
// set stop bits
@ -159,7 +159,7 @@ STATIC void pyb_uart_init_helper(pyb_uart_obj_t *self, size_t n_args, const mp_o
self->stop = 2;
break;
default:
mp_raise_ValueError("invalid stop bits");
mp_raise_ValueError(MP_ERROR_TEXT("invalid stop bits"));
break;
}
@ -198,7 +198,7 @@ STATIC mp_obj_t pyb_uart_make_new(const mp_obj_type_t *type, size_t n_args, size
// get uart id
mp_int_t uart_id = mp_obj_get_int(args[0]);
if (uart_id != 0 && uart_id != 1) {
mp_raise_msg_varg(&mp_type_ValueError, "UART(%d) does not exist", uart_id);
mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("UART(%d) does not exist"), uart_id);
}
// create instance
@ -248,7 +248,7 @@ STATIC mp_uint_t pyb_uart_read(mp_obj_t self_in, void *buf_in, mp_uint_t size, i
pyb_uart_obj_t *self = MP_OBJ_TO_PTR(self_in);
if (self->uart_id == 1) {
mp_raise_msg(&mp_type_OSError, "UART(1) can't read");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("UART(1) can't read"));
}
// make sure we want at least 1 char

8
ports/esp8266/modesp.c
Wyświetl plik

@ -42,7 +42,7 @@
#define MODESP_INCLUDE_CONSTANTS (1)
void error_check(bool status, const char *msg) {
void error_check(bool status, mp_rom_error_text_t msg) {
if (!status) {
mp_raise_msg(&mp_type_OSError, msg);
}
@ -120,7 +120,7 @@ STATIC mp_obj_t esp_flash_write(mp_obj_t offset_in, const mp_obj_t buf_in) {
mp_buffer_info_t bufinfo;
mp_get_buffer_raise(buf_in, &bufinfo, MP_BUFFER_READ);
if (bufinfo.len & 0x3) {
mp_raise_ValueError("len must be multiple of 4");
mp_raise_ValueError(MP_ERROR_TEXT("len must be multiple of 4"));
}
ets_loop_iter(); // flash access takes time so run any pending tasks
SpiFlashOpResult res = spi_flash_write(offset, bufinfo.buf, bufinfo.len);
@ -289,7 +289,7 @@ void *esp_native_code_commit(void *buf, size_t len, void *reloc) {
len = (len + 3) & ~3;
if (esp_native_code_cur + len > esp_native_code_end) {
mp_raise_msg_varg(&mp_type_MemoryError,
"memory allocation failed, allocating %u bytes for native code", (uint)len);
MP_ERROR_TEXT("memory allocation failed, allocating %u bytes for native code"), (uint)len);
}
void *dest;
@ -342,7 +342,7 @@ STATIC mp_obj_t esp_set_native_code_location(mp_obj_t start_in, mp_obj_t len_in)
esp_native_code_erased = esp_native_code_start;
// memory-mapped flash is limited in extents to 1MByte
if (esp_native_code_end > FLASH_END - FLASH_START) {
mp_raise_ValueError("flash location must be below 1MByte");
mp_raise_ValueError(MP_ERROR_TEXT("flash location must be below 1MByte"));
}
}
return mp_const_none;

2
ports/esp8266/modmachine.c
Wyświetl plik

@ -64,7 +64,7 @@ STATIC mp_obj_t machine_freq(size_t n_args, const mp_obj_t *args) {
// set
mp_int_t freq = mp_obj_get_int(args[0]) / 1000000;
if (freq != 80 && freq != 160) {
mp_raise_ValueError("frequency can only be either 80Mhz or 160MHz");
mp_raise_ValueError(MP_ERROR_TEXT("frequency can only be either 80Mhz or 160MHz"));
}
system_update_cpu_freq(freq);
return mp_const_none;

16
ports/esp8266/modnetwork.c
Wyświetl plik

@ -181,7 +181,7 @@ STATIC mp_obj_t esp_status(size_t n_args, const mp_obj_t *args) {
return MP_OBJ_NEW_SMALL_INT(wifi_station_get_rssi());
}
}
mp_raise_ValueError("unknown status param");
mp_raise_ValueError(MP_ERROR_TEXT("unknown status param"));
}
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(esp_status_obj, 1, 2, esp_status);
@ -229,7 +229,7 @@ STATIC void esp_scan_cb(void *result, STATUS status) {
STATIC mp_obj_t esp_scan(mp_obj_t self_in) {
require_if(self_in, STATION_IF);
if ((wifi_get_opmode() & STATION_MODE) == 0) {
mp_raise_msg(&mp_type_OSError, "STA must be active");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("STA must be active"));
}
mp_obj_t list = mp_obj_new_list(0, NULL);
esp_scan_list = &list;
@ -246,7 +246,7 @@ STATIC mp_obj_t esp_scan(mp_obj_t self_in) {
ets_loop_iter();
}
if (list == MP_OBJ_NULL) {
mp_raise_msg(&mp_type_OSError, "scan failed");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("scan failed"));
}
return list;
}
@ -317,7 +317,7 @@ STATIC mp_obj_t esp_ifconfig(size_t n_args, const mp_obj_t *args) {
wifi_softap_dhcps_stop();
}
if (!wifi_set_ip_info(self->if_id, &info)) {
mp_raise_msg(&mp_type_OSError, "wifi_set_ip_info() failed");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("wifi_set_ip_info() failed"));
}
dns_setserver(0, &dns_addr);
if (restart_dhcp_server) {
@ -330,7 +330,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(esp_ifconfig_obj, 1, 2, esp_ifconfig)
STATIC mp_obj_t esp_config(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs) {
if (n_args != 1 && kwargs->used != 0) {
mp_raise_TypeError("either pos or kw args are allowed");
mp_raise_TypeError(MP_ERROR_TEXT("either pos or kw args are allowed"));
}
wlan_if_obj_t *self = MP_OBJ_TO_PTR(args[0]);
@ -357,7 +357,7 @@ STATIC mp_obj_t esp_config(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs
mp_buffer_info_t bufinfo;
mp_get_buffer_raise(kwargs->table[i].value, &bufinfo, MP_BUFFER_READ);
if (bufinfo.len != 6) {
mp_raise_ValueError("invalid buffer length");
mp_raise_ValueError(MP_ERROR_TEXT("invalid buffer length"));
}
wifi_set_macaddr(self->if_id, bufinfo.buf);
break;
@ -427,7 +427,7 @@ STATIC mp_obj_t esp_config(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs
// Get config
if (n_args != 2) {
mp_raise_TypeError("can query only one param");
mp_raise_TypeError(MP_ERROR_TEXT("can query only one param"));
}
mp_obj_t val;
@ -480,7 +480,7 @@ STATIC mp_obj_t esp_config(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs
return val;
unknown:
mp_raise_ValueError("unknown config param");
mp_raise_ValueError(MP_ERROR_TEXT("unknown config param"));
}
STATIC MP_DEFINE_CONST_FUN_OBJ_KW(esp_config_obj, 1, esp_config);

2
ports/esp8266/modutime.c
Wyświetl plik

@ -88,7 +88,7 @@ STATIC mp_obj_t time_mktime(mp_obj_t tuple) {
// 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, "mktime needs a tuple of length 8 or 9 (%d given)", len);
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]),

8
ports/nrf/boards/microbit/modules/microbitdisplay.c
Wyświetl plik

@ -305,7 +305,7 @@ static void draw_object(mp_obj_t obj) {
async_stop();
}
} else {
MP_STATE_VM(mp_pending_exception) = mp_obj_new_exception_msg(&mp_type_TypeError, "not an image.");
MP_STATE_VM(mp_pending_exception) = mp_obj_new_exception_msg(&mp_type_TypeError, MP_ERROR_TEXT("not an image."));
async_stop();
}
}
@ -499,10 +499,10 @@ MP_DEFINE_CONST_FUN_OBJ_1(microbit_display_clear_obj, microbit_display_clear_fun
void microbit_display_set_pixel(microbit_display_obj_t *display, mp_int_t x, mp_int_t y, mp_int_t bright) {
if (x < 0 || y < 0 || x > 4 || y > 4) {
mp_raise_ValueError("index out of bounds.");
mp_raise_ValueError(MP_ERROR_TEXT("index out of bounds."));
}
if (bright < 0 || bright > MAX_BRIGHTNESS) {
mp_raise_ValueError("brightness out of bounds.");
mp_raise_ValueError(MP_ERROR_TEXT("brightness out of bounds."));
}
display->image_buffer[x][y] = bright;
display->brightnesses |= (1 << bright);
@ -518,7 +518,7 @@ MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(microbit_display_set_pixel_obj, 4, 4, microb
mp_int_t microbit_display_get_pixel(microbit_display_obj_t *display, mp_int_t x, mp_int_t y) {
if (x < 0 || y < 0 || x > 4 || y > 4) {
mp_raise_ValueError("index out of bounds.");
mp_raise_ValueError(MP_ERROR_TEXT("index out of bounds."));
}
return display->image_buffer[x][y];
}

32
ports/nrf/boards/microbit/modules/microbitimage.c
Wyświetl plik

@ -162,7 +162,7 @@ STATIC microbit_image_obj_t *image_from_parsed_str(const char *s, mp_int_t len)
} else if ('c' >= '0' && c <= '9') {
++line_len;
} else {
mp_raise_ValueError("Unexpected character in Image definition.");
mp_raise_ValueError(MP_ERROR_TEXT("Unexpected character in Image definition."));
}
}
if (line_len) {
@ -227,7 +227,7 @@ STATIC mp_obj_t microbit_image_make_new(const mp_obj_type_t *type_in, mp_uint_t
return image_from_parsed_str(str, len);
}
} else {
mp_raise_TypeError("Image(s) takes a string.");
mp_raise_TypeError(MP_ERROR_TEXT("Image(s) takes a string."));
}
}
@ -243,7 +243,7 @@ STATIC mp_obj_t microbit_image_make_new(const mp_obj_type_t *type_in, mp_uint_t
mp_get_buffer_raise(args[2], &bufinfo, MP_BUFFER_READ);
if (w < 0 || h < 0 || (size_t)(w * h) != bufinfo.len) {
mp_raise_ValueError("image data is incorrect size");
mp_raise_ValueError(MP_ERROR_TEXT("image data is incorrect size"));
}
mp_int_t i = 0;
for (mp_int_t y = 0; y < h; y++) {
@ -258,7 +258,7 @@ STATIC mp_obj_t microbit_image_make_new(const mp_obj_type_t *type_in, mp_uint_t
}
default: {
mp_raise_TypeError("Image() takes 0 to 3 arguments");
mp_raise_TypeError(MP_ERROR_TEXT("Image() takes 0 to 3 arguments"));
}
}
}
@ -351,19 +351,19 @@ mp_obj_t microbit_image_get_pixel(mp_obj_t self_in, mp_obj_t x_in, mp_obj_t y_in
mp_int_t x = mp_obj_get_int(x_in);
mp_int_t y = mp_obj_get_int(y_in);
if (x < 0 || y < 0) {
mp_raise_ValueError("index cannot be negative");
mp_raise_ValueError(MP_ERROR_TEXT("index cannot be negative"));
}
if (x < imageWidth(self) && y < imageHeight(self)) {
return MP_OBJ_NEW_SMALL_INT(imageGetPixelValue(self, x, y));
}
mp_raise_ValueError("index too large");
mp_raise_ValueError(MP_ERROR_TEXT("index too large"));
}
MP_DEFINE_CONST_FUN_OBJ_3(microbit_image_get_pixel_obj, microbit_image_get_pixel);
/* Raise an exception if not mutable */
static void check_mutability(microbit_image_obj_t *self) {
if (self->base.five) {
mp_raise_TypeError("image cannot be modified (try copying first)");
mp_raise_TypeError(MP_ERROR_TEXT("image cannot be modified (try copying first)"));
}
}
@ -375,16 +375,16 @@ mp_obj_t microbit_image_set_pixel(mp_uint_t n_args, const mp_obj_t *args) {
mp_int_t x = mp_obj_get_int(args[1]);
mp_int_t y = mp_obj_get_int(args[2]);
if (x < 0 || y < 0) {
mp_raise_ValueError("index cannot be negative");
mp_raise_ValueError(MP_ERROR_TEXT("index cannot be negative"));
}
mp_int_t bright = mp_obj_get_int(args[3]);
if (bright < 0 || bright > MAX_BRIGHTNESS)
mp_raise_ValueError("brightness out of bounds.");
mp_raise_ValueError(MP_ERROR_TEXT("brightness out of bounds."));
if (x < imageWidth(self) && y < imageHeight(self)) {
greyscaleSetPixelValue(&(self->greyscale), x, y, bright);
return mp_const_none;
}
mp_raise_ValueError("index too large");
mp_raise_ValueError(MP_ERROR_TEXT("index too large"));
}
MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(microbit_image_set_pixel_obj, 4, 4, microbit_image_set_pixel);
@ -393,7 +393,7 @@ mp_obj_t microbit_image_fill(mp_obj_t self_in, mp_obj_t n_in) {
check_mutability(self);
mp_int_t n = mp_obj_get_int(n_in);
if (n < 0 || n > MAX_BRIGHTNESS) {
mp_raise_ValueError("brightness out of bounds.");
mp_raise_ValueError(MP_ERROR_TEXT("brightness out of bounds."));
}
greyscaleFill(&self->greyscale, n);
return mp_const_none;
@ -406,17 +406,17 @@ mp_obj_t microbit_image_blit(mp_uint_t n_args, const mp_obj_t *args) {
mp_obj_t src = args[1];
if (mp_obj_get_type(src) != &microbit_image_type) {
mp_raise_TypeError("expecting an image");
mp_raise_TypeError(MP_ERROR_TEXT("expecting an image"));
}
if (n_args == 7) {
mp_raise_TypeError("must specify both offsets");
mp_raise_TypeError(MP_ERROR_TEXT("must specify both offsets"));
}
mp_int_t x = mp_obj_get_int(args[2]);
mp_int_t y = mp_obj_get_int(args[3]);
mp_int_t w = mp_obj_get_int(args[4]);
mp_int_t h = mp_obj_get_int(args[5]);
if (w < 0 || h < 0) {
mp_raise_ValueError("size cannot be negative");
mp_raise_ValueError(MP_ERROR_TEXT("size cannot be negative"));
}
mp_int_t xdest;
mp_int_t ydest;
@ -608,7 +608,7 @@ microbit_image_obj_t *microbit_image_dim(microbit_image_obj_t *lhs, mp_float_t f
microbit_image_obj_t *microbit_image_dim(microbit_image_obj_t *lhs, mp_int_t fval) {
#endif
if (fval < 0)
mp_raise_ValueError("Brightness multiplier must not be negative.");
mp_raise_ValueError(MP_ERROR_TEXT("Brightness multiplier must not be negative."));
greyscale_t *result = greyscale_new(imageWidth(lhs), imageHeight(lhs));
for (int x = 0; x < imageWidth(lhs); ++x) {
for (int y = 0; y < imageWidth(lhs); ++y) {
@ -628,7 +628,7 @@ microbit_image_obj_t *microbit_image_sum(microbit_image_obj_t *lhs, microbit_ima
mp_int_t w = imageWidth(lhs);
if (imageHeight(rhs) != h || imageWidth(lhs) != w) {
// TODO: verify that image width in test above should really test (lhs != w)
mp_raise_ValueError("Images must be the same size.");
mp_raise_ValueError(MP_ERROR_TEXT("Images must be the same size."));
}
greyscale_t *result = greyscale_new(w, h);
for (int x = 0; x < w; ++x) {

26
ports/nrf/drivers/bluetooth/ble_drv.c
Wyświetl plik

@ -223,7 +223,7 @@ uint32_t ble_drv_stack_enable(void) {
if ((err_code = sd_ble_gap_device_name_set(&sec_mode,
(const uint8_t *)device_name,
strlen(device_name))) != 0) {
mp_raise_msg(&mp_type_OSError, "can't apply GAP parameters");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("can't apply GAP parameters"));
}
// set connection parameters
@ -235,7 +235,7 @@ uint32_t ble_drv_stack_enable(void) {
gap_conn_params.conn_sup_timeout = BLE_CONN_SUP_TIMEOUT;
if (sd_ble_gap_ppcp_set(&gap_conn_params) != 0) {
mp_raise_msg(&mp_type_OSError, "can't set PPCP parameters");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("can't set PPCP parameters"));
}
return err_code;
@ -266,7 +266,7 @@ void ble_drv_address_get(ble_drv_addr_t * p_addr) {
#endif
if (err_code != 0) {
mp_raise_msg(&mp_type_OSError, "can't query for the device address");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("can't query for the device address"));
}
BLE_DRIVER_LOG("ble address, type: " HEX2_FMT ", " \
@ -284,7 +284,7 @@ bool ble_drv_uuid_add_vs(uint8_t * p_uuid, uint8_t * idx) {
SD_TEST_OR_ENABLE();
if (sd_ble_uuid_vs_add((ble_uuid128_t const *)p_uuid, idx) != 0) {
mp_raise_msg(&mp_type_OSError, "can't add Vendor Specific 128-bit UUID");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("can't add Vendor Specific 128-bit UUID"));
}
return true;
@ -303,7 +303,7 @@ bool ble_drv_service_add(ubluepy_service_obj_t * p_service_obj) {
if (sd_ble_gatts_service_add(p_service_obj->type,
&uuid,
&p_service_obj->handle) != 0) {
mp_raise_msg(&mp_type_OSError, "can't add Service");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("can't add Service"));
}
} else if (p_service_obj->p_uuid->type == BLE_UUID_TYPE_BLE) {
BLE_DRIVER_LOG("adding service\n");
@ -316,7 +316,7 @@ bool ble_drv_service_add(ubluepy_service_obj_t * p_service_obj) {
if (sd_ble_gatts_service_add(p_service_obj->type,
&uuid,
&p_service_obj->handle) != 0) {
mp_raise_msg(&mp_type_OSError, "can't add Service");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("can't add Service"));
}
}
return true;
@ -386,7 +386,7 @@ bool ble_drv_characteristic_add(ubluepy_characteristic_obj_t * p_char_obj) {
&char_md,
&attr_char_value,
&handles) != 0) {
mp_raise_msg(&mp_type_OSError, "can't add Characteristic");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("can't add Characteristic"));
}
// apply handles to object instance
@ -413,7 +413,7 @@ bool ble_drv_advertise_data(ubluepy_advertise_data_t * p_adv_params) {
if (sd_ble_gap_device_name_set(&sec_mode,
p_adv_params->p_device_name,
p_adv_params->device_name_len) != 0) {
mp_raise_msg(&mp_type_OSError, "can't apply device name in the stack");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("can't apply device name in the stack"));
}
BLE_DRIVER_LOG("Device name applied\n");
@ -476,12 +476,12 @@ bool ble_drv_advertise_data(ubluepy_advertise_data_t * p_adv_params) {
uuid.uuid += p_service->p_uuid->value[1] << 8;
// calculate total size of uuids
if (sd_ble_uuid_encode(&uuid, &encoded_size, NULL) != 0) {
mp_raise_msg(&mp_type_OSError, "can't encode UUID, to check length");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("can't encode UUID, to check length"));
}
// do encoding into the adv buffer
if (sd_ble_uuid_encode(&uuid, &encoded_size, &adv_data[byte_pos]) != 0) {
mp_raise_msg(&mp_type_OSError, "can't encode UUID into advertisment packet");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("can't encode UUID into advertisment packet"));
}
BLE_DRIVER_LOG("encoded uuid for service %u: ", 0);
@ -524,12 +524,12 @@ bool ble_drv_advertise_data(ubluepy_advertise_data_t * p_adv_params) {
// calculate total size of uuids
if (sd_ble_uuid_encode(&uuid, &encoded_size, NULL) != 0) {
mp_raise_msg(&mp_type_OSError, "can't encode UUID, to check length");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("can't encode UUID, to check length"));
}
// do encoding into the adv buffer
if (sd_ble_uuid_encode(&uuid, &encoded_size, &adv_data[byte_pos]) != 0) {
mp_raise_msg(&mp_type_OSError, "can't encode UUID into advertisment packet");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("can't encode UUID into advertisment packet"));
}
BLE_DRIVER_LOG("encoded uuid for service %u: ", 0);
@ -553,7 +553,7 @@ bool ble_drv_advertise_data(ubluepy_advertise_data_t * p_adv_params) {
if ((p_adv_params->data_len > 0) && (p_adv_params->p_data != NULL)) {
if (p_adv_params->data_len + byte_pos > BLE_GAP_ADV_MAX_SIZE) {
mp_raise_msg(&mp_type_OSError, "can't fit data into advertisment packet");
mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("can't fit data into advertisment packet"));
}
memcpy(adv_data, p_adv_params->p_data, p_adv_params->data_len);

2
ports/nrf/modules/board/led.c
Wyświetl plik

@ -151,7 +151,7 @@ STATIC mp_obj_t led_obj_make_new(const mp_obj_type_t *type, size_t n_args, size_
// check led number
if (!(1 <= led_id && led_id <= NUM_LEDS)) {
mp_raise_ValueError("LED doesn't exist");
mp_raise_ValueError(MP_ERROR_TEXT("LED doesn't exist"));
}
// return static led object

4
ports/nrf/modules/machine/adc.c
Wyświetl plik

@ -101,7 +101,7 @@ STATIC int adc_find(mp_obj_t id) {
if (pin->adc_num & PIN_ADC1) {
adc_idx = pin->adc_channel;
} else {
mp_raise_ValueError("invalid Pin for ADC");
mp_raise_ValueError(MP_ERROR_TEXT("invalid Pin for ADC"));
}
}
@ -109,7 +109,7 @@ STATIC int adc_find(mp_obj_t id) {
&& machine_adc_obj[adc_idx].id != (uint8_t)-1) {
return adc_idx;
}
mp_raise_ValueError("ADC doesn't exist");
mp_raise_ValueError(MP_ERROR_TEXT("ADC doesn't exist"));
}
/// \method __str__()

2
ports/nrf/modules/machine/i2c.c
Wyświetl plik

@ -80,7 +80,7 @@ STATIC int i2c_find(mp_obj_t id) {
if (i2c_id >= 0 && i2c_id < MP_ARRAY_SIZE(machine_hard_i2c_obj)) {
return i2c_id;
}
mp_raise_ValueError("I2C doesn't exist");
mp_raise_ValueError(MP_ERROR_TEXT("I2C doesn't exist"));
}
STATIC void machine_hard_i2c_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {

6
ports/nrf/modules/machine/pin.c
Wyświetl plik

@ -150,7 +150,7 @@ const pin_obj_t *pin_find(mp_obj_t user_obj) {
pin_obj = mp_call_function_1(MP_STATE_PORT(pin_class_mapper), user_obj);
if (pin_obj != mp_const_none) {
if (!mp_obj_is_type(pin_obj, &pin_type)) {
mp_raise_ValueError("Pin.mapper didn't return a Pin object");
mp_raise_ValueError(MP_ERROR_TEXT("Pin.mapper didn't return a Pin object"));
}
if (pin_class_debug) {
printf("Pin.mapper maps ");
@ -207,7 +207,7 @@ const pin_obj_t *pin_find(mp_obj_t user_obj) {
return pin_obj;
}
mp_raise_ValueError("not a valid pin identifier");
mp_raise_ValueError(MP_ERROR_TEXT("not a valid pin identifier"));
}
/// \method __str__()
@ -375,7 +375,7 @@ STATIC mp_obj_t pin_obj_init_helper(const pin_obj_t *self, mp_uint_t n_args, con
NRF_GPIO_PIN_S0S1,
NRF_GPIO_PIN_NOSENSE);
} else {
mp_raise_msg_varg(&mp_type_ValueError, "invalid pin mode: %d", mode);
mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("invalid pin mode: %d"), mode);
}
return mp_const_none;

4
ports/nrf/modules/machine/pwm.c
Wyświetl plik

@ -97,7 +97,7 @@ STATIC int hard_pwm_find(mp_obj_t id) {
if (pwm_id >= 0 && pwm_id < MP_ARRAY_SIZE(machine_hard_pwm_obj)) {
return pwm_id;
}
mp_raise_ValueError("PWM doesn't exist");
mp_raise_ValueError(MP_ERROR_TEXT("PWM doesn't exist"));
}
return -1;
}
@ -249,7 +249,7 @@ STATIC mp_obj_t machine_hard_pwm_make_new(mp_arg_val_t *args) {
if (args[ARG_period].u_obj != MP_OBJ_NULL) {
self->p_config->period = mp_obj_get_int(args[ARG_period].u_obj);
} else {
mp_raise_ValueError("PWM period must be within 16000 cycles");
mp_raise_ValueError(MP_ERROR_TEXT("PWM period must be within 16000 cycles"));
}
if (args[ARG_duty].u_obj != MP_OBJ_NULL) {

4
ports/nrf/modules/machine/rtcounter.c
Wyświetl plik

@ -116,7 +116,7 @@ STATIC int rtc_find(mp_obj_t id) {
if (rtc_id >= 0 && rtc_id < MP_ARRAY_SIZE(machine_rtc_obj)) {
return rtc_id;
}
mp_raise_ValueError("RTCounter doesn't exist");
mp_raise_ValueError(MP_ERROR_TEXT("RTCounter doesn't exist"));
}
STATIC void rtc_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
@ -162,7 +162,7 @@ STATIC mp_obj_t machine_rtc_make_new(const mp_obj_type_t *type, size_t n_args, s
} else if (mp_obj_is_fun(args[ARG_callback].u_obj)) {
config->callback = args[ARG_callback].u_obj;
} else {
mp_raise_ValueError("callback must be a function");
mp_raise_ValueError(MP_ERROR_TEXT("callback must be a function"));
}
// Periodic or one-shot

6
ports/nrf/modules/machine/spi.c
Wyświetl plik

@ -140,14 +140,14 @@ STATIC int spi_find(mp_obj_t id) {
return 1;
#endif
}
mp_raise_ValueError("SPI doesn't exist");
mp_raise_ValueError(MP_ERROR_TEXT("SPI doesn't exist"));
} else {
// given an integer id
int spi_id = mp_obj_get_int(id);
if (spi_id >= 0 && spi_id < MP_ARRAY_SIZE(machine_hard_spi_obj)) {
return spi_id;
}
mp_raise_ValueError("SPI doesn't exist");
mp_raise_ValueError(MP_ERROR_TEXT("SPI doesn't exist"));
}
}
@ -415,7 +415,7 @@ STATIC mp_obj_t mp_machine_spi_write_readinto(mp_obj_t self, mp_obj_t wr_buf, mp
mp_buffer_info_t dest;
mp_get_buffer_raise(rd_buf, &dest, MP_BUFFER_WRITE);
if (src.len != dest.len) {
mp_raise_ValueError("buffers must be the same length");
mp_raise_ValueError(MP_ERROR_TEXT("buffers must be the same length"));
}
spi_transfer(self, src.len, src.buf, dest.buf);
return mp_const_none;

8
ports/nrf/modules/machine/timer.c
Wyświetl plik

@ -77,7 +77,7 @@ STATIC int timer_find(mp_obj_t id) {
if (timer_id >= 0 && timer_id < MP_ARRAY_SIZE(machine_timer_obj)) {
return timer_id;
}
mp_raise_ValueError("Timer doesn't exist");
mp_raise_ValueError(MP_ERROR_TEXT("Timer doesn't exist"));
}
STATIC void timer_print(const mp_print_t *print, mp_obj_t o, mp_print_kind_t kind) {
@ -114,13 +114,13 @@ STATIC mp_obj_t machine_timer_make_new(const mp_obj_type_t *type, size_t n_args,
#if BLUETOOTH_SD
if (timer_id == 0) {
mp_raise_ValueError("Timer reserved by Bluetooth LE stack");
mp_raise_ValueError(MP_ERROR_TEXT("Timer reserved by Bluetooth LE stack"));
}
#endif
#if MICROPY_PY_MACHINE_SOFT_PWM
if (timer_id == 1) {
mp_raise_ValueError("Timer reserved by ticker driver");
mp_raise_ValueError(MP_ERROR_TEXT("Timer reserved by ticker driver"));
}
#endif
@ -131,7 +131,7 @@ STATIC mp_obj_t machine_timer_make_new(const mp_obj_type_t *type, size_t n_args,
} else if (args[ARG_callback].u_obj == mp_const_none) {
machine_timer_callbacks[timer_id] = NULL;
} else {
mp_raise_ValueError("callback must be a function");
mp_raise_ValueError(MP_ERROR_TEXT("callback must be a function"));
}
// Timer peripheral usage:

4
ports/nrf/modules/machine/uart.c
Wyświetl plik

@ -118,7 +118,7 @@ STATIC int uart_find(mp_obj_t id) {
if (uart_id >= 0 && uart_id < MP_ARRAY_SIZE(machine_hard_uart_obj)) {
return uart_id;
}
mp_raise_ValueError("UART doesn't exist");
mp_raise_ValueError(MP_ERROR_TEXT("UART doesn't exist"));
}
STATIC void uart_event_handler(nrfx_uart_event_t const *p_event, void *p_context) {
@ -215,7 +215,7 @@ STATIC mp_obj_t machine_hard_uart_make_new(const mp_obj_type_t *type, size_t n_a
// These baudrates are not supported, it seems.
if (args[ARG_baudrate].u_int < 1200 || args[ARG_baudrate].u_int > 1000000) {
mp_raise_ValueError("UART baudrate not supported");
mp_raise_ValueError(MP_ERROR_TEXT("UART baudrate not supported"));
}
// Magic: calculate 'baudrate' register from the input number.

8
ports/nrf/modules/music/modmusic.c
Wyświetl plik

@ -284,7 +284,7 @@ STATIC mp_obj_t microbit_music_stop(mp_uint_t n_args, const mp_obj_t *args) {
#ifdef MICROPY_HW_MUSIC_PIN
pin = mp_hal_get_pin_obj(MP_OBJ_NEW_SMALL_INT(MICROPY_HW_MUSIC_PIN));
#else
mp_raise_ValueError("pin parameter not given");
mp_raise_ValueError(MP_ERROR_TEXT("pin parameter not given"));
#endif
} else {
pin = (pin_obj_t *)args[0];
@ -337,7 +337,7 @@ STATIC mp_obj_t microbit_music_play(mp_uint_t n_args, const mp_obj_t *pos_args,
#ifdef MICROPY_HW_MUSIC_PIN
pin = mp_hal_get_pin_obj(MP_OBJ_NEW_SMALL_INT(MICROPY_HW_MUSIC_PIN));
#else
mp_raise_ValueError("pin parameter not given");
mp_raise_ValueError(MP_ERROR_TEXT("pin parameter not given"));
#endif
} else {
pin = (pin_obj_t *)args[1].u_obj;
@ -392,7 +392,7 @@ STATIC mp_obj_t microbit_music_pitch(mp_uint_t n_args, const mp_obj_t *pos_args,
#ifdef MICROPY_HW_MUSIC_PIN
pin = mp_hal_get_pin_obj(MP_OBJ_NEW_SMALL_INT(MICROPY_HW_MUSIC_PIN));
#else
mp_raise_ValueError("pin parameter not given");
mp_raise_ValueError(MP_ERROR_TEXT("pin parameter not given"));
#endif
} else {
pin = (pin_obj_t *)args[2].u_obj;
@ -408,7 +408,7 @@ STATIC mp_obj_t microbit_music_pitch(mp_uint_t n_args, const mp_obj_t *pos_args,
//TODO: pwm_release(pin->name);
} else if (pwm_set_period_us(1000000/frequency)) {
pwm_release(pin->pin); // TODO: remove pin setting.
mp_raise_ValueError("invalid pitch");
mp_raise_ValueError(MP_ERROR_TEXT("invalid pitch"));
}
if (duration >= 0) {
// use async machinery to stop the pitch after the duration

2
ports/nrf/modules/ubluepy/ubluepy_characteristic.c
Wyświetl plik

@ -63,7 +63,7 @@ STATIC mp_obj_t ubluepy_characteristic_make_new(const mp_obj_type_t *type, size_
s->p_uuid = MP_OBJ_TO_PTR(uuid_obj);
// (void)sd_characterstic_add(s);
} else {
mp_raise_ValueError("Invalid UUID parameter");
mp_raise_ValueError(MP_ERROR_TEXT("Invalid UUID parameter"));
}
if (args[1].u_int > 0) {

6
ports/nrf/modules/ubluepy/ubluepy_service.c
Wyświetl plik

@ -68,13 +68,13 @@ STATIC mp_obj_t ubluepy_service_make_new(const mp_obj_type_t *type, size_t n_arg
if (type > 0 && type <= UBLUEPY_SERVICE_PRIMARY) {
s->type = type;
} else {
mp_raise_ValueError("Invalid Service type");
mp_raise_ValueError(MP_ERROR_TEXT("Invalid Service type"));
}
(void)ble_drv_service_add(s);
} else {
mp_raise_ValueError("Invalid UUID parameter");
mp_raise_ValueError(MP_ERROR_TEXT("Invalid UUID parameter"));
}
// clear reference to peripheral
@ -125,7 +125,7 @@ STATIC mp_obj_t service_get_characteristic(mp_obj_t self_in, mp_obj_t uuid) {
// validate that there is an UUID object passed in as parameter
if (!(mp_obj_is_type(uuid, &ubluepy_uuid_type))) {
mp_raise_ValueError("Invalid UUID parameter");
mp_raise_ValueError(MP_ERROR_TEXT("Invalid UUID parameter"));
}
mp_obj_t * chars = NULL;

4
ports/nrf/modules/ubluepy/ubluepy_uuid.c
Wyświetl plik

@ -122,7 +122,7 @@ STATIC mp_obj_t ubluepy_uuid_make_new(const mp_obj_type_t *type, size_t n_args,
ble_drv_uuid_add_vs(buffer, &s->uuid_vs_idx);
} else {
mp_raise_ValueError("Invalid UUID string length");
mp_raise_ValueError(MP_ERROR_TEXT("Invalid UUID string length"));
}
} else if (mp_obj_is_type(uuid_obj, &ubluepy_uuid_type)) {
// deep copy instance
@ -131,7 +131,7 @@ STATIC mp_obj_t ubluepy_uuid_make_new(const mp_obj_type_t *type, size_t n_args,
s->value[0] = p_old->value[0];
s->value[1] = p_old->value[1];
} else {
mp_raise_ValueError("Invalid UUID parameter");
mp_raise_ValueError(MP_ERROR_TEXT("Invalid UUID parameter"));
}
return MP_OBJ_FROM_PTR(s);

4
ports/nrf/modules/uos/microbitfs.c
Wyświetl plik

@ -389,7 +389,7 @@ STATIC mp_obj_t microbit_remove(mp_obj_t filename) {
STATIC void check_file_open(file_descriptor_obj *self) {
if (!self->open) {
mp_raise_ValueError("I/O operation on closed file");
mp_raise_ValueError(MP_ERROR_TEXT("I/O operation on closed file"));
}
}
@ -685,7 +685,7 @@ mp_obj_t uos_mbfs_open(size_t n_args, const mp_obj_t *args) {
}
return res;
mode_error:
mp_raise_ValueError("illegal mode");
mp_raise_ValueError(MP_ERROR_TEXT("illegal mode"));
}
STATIC mp_obj_t uos_mbfs_stat(mp_obj_t filename) {

2
ports/nrf/modules/uos/moduos.c
Wyświetl plik

@ -128,7 +128,7 @@ STATIC mp_obj_t os_dupterm(mp_uint_t n_args, const mp_obj_t *args) {
} else if (mp_obj_get_type(args[0]) == &machine_hard_uart_type) {
MP_STATE_PORT(board_stdio_uart) = args[0];
} else {
mp_raise_ValueError("need a UART object");
mp_raise_ValueError(MP_ERROR_TEXT("need a UART object"));
}
return mp_const_none;
}

Some files were not shown because too many files have changed in this diff Show More