atmel-samd: Introduce a nvm module for non-volatile byte-level memory access. (#203)
* atmel-samd: Introduce a nvm module for non-volatile byte-level memory access. This allows for persisting small configuration values even when the file system is read-only from CircuitPython. Fixes #160 * Review feedback: * Add tests. * Fix non-zero index. * Fix len()crypto-aes
Scott Shawcroft
6 years ago
committed by
Dan Halbert
parent
dd1c4fc8c7
commit
266be30777
@ -0,0 +1,88 @@
|
||||
/*
|
||||
* This file is part of the Micro Python project, http://micropython.org/
|
||||
*
|
||||
* The MIT License (MIT)
|
||||
*
|
||||
* Copyright (c) 2017 Scott Shawcroft for Adafruit Industries
|
||||
*
|
||||
* 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 "common-hal/nvm/ByteArray.h"
|
||||
|
||||
#include "asf/sam0/drivers/nvm/nvm.h"
|
||||
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
|
||||
uint32_t common_hal_nvm_bytearray_get_length(nvm_bytearray_obj_t *self) {
|
||||
return self->len;
|
||||
}
|
||||
|
||||
bool common_hal_nvm_bytearray_set_bytes(nvm_bytearray_obj_t *self,
|
||||
uint32_t start_index, uint8_t* values, uint32_t len) {
|
||||
uint32_t total_written = 0;
|
||||
for (uint32_t i = 0; i < self->len / NVMCTRL_ROW_SIZE; i++) {
|
||||
uint32_t row_start = NVMCTRL_ROW_SIZE * i;
|
||||
if (row_start + NVMCTRL_ROW_SIZE < start_index || start_index + len < row_start) {
|
||||
continue;
|
||||
}
|
||||
uint8_t temp_row[NVMCTRL_ROW_SIZE];
|
||||
memcpy(temp_row,
|
||||
self->start_address + row_start,
|
||||
NVMCTRL_ROW_SIZE);
|
||||
enum status_code error_code;
|
||||
do {
|
||||
error_code = nvm_erase_row((uint32_t) self->start_address + row_start);
|
||||
} while (error_code == STATUS_BUSY);
|
||||
if (error_code != STATUS_OK) {
|
||||
return false;
|
||||
}
|
||||
uint32_t data_start = 0;
|
||||
if (start_index > row_start) {
|
||||
data_start = start_index - row_start;
|
||||
}
|
||||
uint32_t data_len = len;
|
||||
uint32_t data_remaining = data_len - total_written;
|
||||
uint32_t row_remaining = NVMCTRL_ROW_SIZE - data_start;
|
||||
if (data_remaining > row_remaining) {
|
||||
data_len = row_remaining;
|
||||
}
|
||||
memcpy(temp_row + data_start,
|
||||
values + total_written,
|
||||
data_len);
|
||||
for (int page = 0; page < NVMCTRL_ROW_SIZE / NVMCTRL_PAGE_SIZE; page++) {
|
||||
do {
|
||||
error_code = nvm_write_buffer((uint32_t) self->start_address + row_start + page * NVMCTRL_PAGE_SIZE,
|
||||
temp_row + page * NVMCTRL_PAGE_SIZE,
|
||||
NVMCTRL_PAGE_SIZE);
|
||||
} while (error_code == STATUS_BUSY);
|
||||
if (error_code != STATUS_OK) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
// NVM memory is memory mapped so reading it is easy.
|
||||
void common_hal_nvm_bytearray_get_bytes(nvm_bytearray_obj_t *self,
|
||||
uint32_t start_index, uint32_t len, uint8_t* values) {
|
||||
memcpy(values, self->start_address + start_index, len);
|
||||
}
|
||||
@ -0,0 +1,38 @@
|
||||
/*
|
||||
* This file is part of the MicroPython project, http://micropython.org/
|
||||
*
|
||||
* The MIT License (MIT)
|
||||
*
|
||||
* Copyright (c) 2017 Scott Shawcroft for Adafruit Industries
|
||||
*
|
||||
* 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_ATMEL_SAMD_COMMON_HAL_NVM_BYTEARRAY_H__
|
||||
#define __MICROPY_INCLUDED_ATMEL_SAMD_COMMON_HAL_NVM_BYTEARRAY_H__
|
||||
|
||||
#include "py/obj.h"
|
||||
|
||||
typedef struct {
|
||||
mp_obj_base_t base;
|
||||
uint8_t* start_address;
|
||||
uint32_t len;
|
||||
} nvm_bytearray_obj_t;
|
||||
|
||||
#endif // __MICROPY_INCLUDED_ATMEL_SAMD_COMMON_HAL_NVM_BYTEARRAY_H__
|
||||
@ -0,0 +1 @@
|
||||
// No nvm module functions.
|
||||
@ -0,0 +1,159 @@
|
||||
/*
|
||||
* This file is part of the Micro Python project, http://micropython.org/
|
||||
*
|
||||
* The MIT License (MIT)
|
||||
*
|
||||
* Copyright (c) 2017 Scott Shawcroft for Adafruit Industries
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
* THE SOFTWARE.
|
||||
*/
|
||||
|
||||
#include "py/binary.h"
|
||||
#include "py/objproperty.h"
|
||||
#include "py/runtime.h"
|
||||
#include "py/runtime0.h"
|
||||
#include "shared-bindings/nvm/ByteArray.h"
|
||||
|
||||
//| .. currentmodule:: nvm
|
||||
//|
|
||||
//| :class:`ByteArray` -- Presents a stretch of non-volatile memory as a bytearray.
|
||||
//| ================================================================================
|
||||
//|
|
||||
//| Non-volatile memory is available as a byte array that persists over reloads
|
||||
//| and power cycles.
|
||||
//|
|
||||
//| Usage::
|
||||
//|
|
||||
//| import microcontroller
|
||||
//| microcontroller.nvm[0] = 0xcc
|
||||
//|
|
||||
|
||||
//| .. class:: ByteArray()
|
||||
//|
|
||||
//| Not currently dynamically supported. Access one through `microcontroller.nvm`.
|
||||
//|
|
||||
STATIC mp_obj_t nvm_bytearray_make_new(const mp_obj_type_t *type,
|
||||
mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *args) {
|
||||
return mp_const_none;
|
||||
}
|
||||
|
||||
//| .. method:: __len__()
|
||||
//|
|
||||
//| Return the length. This is used by (`len`)
|
||||
//|
|
||||
STATIC mp_obj_t nvm_bytearray_unary_op(mp_uint_t op, mp_obj_t self_in) {
|
||||
nvm_bytearray_obj_t *self = MP_OBJ_TO_PTR(self_in);
|
||||
uint16_t len = common_hal_nvm_bytearray_get_length(self);
|
||||
switch (op) {
|
||||
case MP_UNARY_OP_BOOL: return mp_obj_new_bool(len != 0);
|
||||
case MP_UNARY_OP_LEN: return MP_OBJ_NEW_SMALL_INT(len);
|
||||
default: return MP_OBJ_NULL; // op not supported
|
||||
}
|
||||
}
|
||||
|
||||
STATIC const mp_rom_map_elem_t nvm_bytearray_locals_dict_table[] = {
|
||||
};
|
||||
|
||||
STATIC MP_DEFINE_CONST_DICT(nvm_bytearray_locals_dict, nvm_bytearray_locals_dict_table);
|
||||
|
||||
STATIC mp_obj_t nvm_bytearray_subscr(mp_obj_t self_in, mp_obj_t index_in, mp_obj_t value) {
|
||||
if (value == MP_OBJ_NULL) {
|
||||
// delete item
|
||||
// slice deletion
|
||||
return MP_OBJ_NULL; // op not supported
|
||||
} else {
|
||||
nvm_bytearray_obj_t *self = MP_OBJ_TO_PTR(self_in);
|
||||
if (0) {
|
||||
#if MICROPY_PY_BUILTINS_SLICE
|
||||
} else if (MP_OBJ_IS_TYPE(index_in, &mp_type_slice)) {
|
||||
mp_bound_slice_t slice;
|
||||
if (!mp_seq_get_fast_slice_indexes(common_hal_nvm_bytearray_get_length(self), index_in, &slice)) {
|
||||
mp_raise_NotImplementedError("only slices with step=1 (aka None) are supported");
|
||||
}
|
||||
if (value != MP_OBJ_SENTINEL) {
|
||||
#if MICROPY_PY_ARRAY_SLICE_ASSIGN
|
||||
// Assign
|
||||
size_t src_len = slice.stop - slice.start;
|
||||
uint8_t* src_items;
|
||||
if (MP_OBJ_IS_TYPE(value, &mp_type_array) ||
|
||||
MP_OBJ_IS_TYPE(value, &mp_type_bytearray) ||
|
||||
MP_OBJ_IS_TYPE(value, &mp_type_memoryview) ||
|
||||
MP_OBJ_IS_TYPE(value, &mp_type_bytes)) {
|
||||
mp_buffer_info_t bufinfo;
|
||||
mp_get_buffer_raise(value, &bufinfo, MP_BUFFER_READ);
|
||||
if (bufinfo.len != src_len) {
|
||||
mp_raise_ValueError("Slice and value different lengths.");
|
||||
}
|
||||
src_len = bufinfo.len;
|
||||
src_items = bufinfo.buf;
|
||||
if (1 != mp_binary_get_size('@', bufinfo.typecode, NULL)) {
|
||||
mp_raise_ValueError("Array values should be single bytes.");
|
||||
}
|
||||
} else {
|
||||
mp_raise_NotImplementedError("array/bytes required on right side");
|
||||
}
|
||||
|
||||
if (!common_hal_nvm_bytearray_set_bytes(self, slice.start, src_items, src_len)) {
|
||||
mp_raise_RuntimeError("Unable to write to nvm.");
|
||||
}
|
||||
return mp_const_none;
|
||||
#else
|
||||
return MP_OBJ_NULL; // op not supported
|
||||
#endif
|
||||
} else {
|
||||
// Read slice.
|
||||
size_t len = slice.stop - slice.start;
|
||||
uint8_t *items = m_new(uint8_t, len);
|
||||
common_hal_nvm_bytearray_get_bytes(self, slice.start, len, items);
|
||||
return mp_obj_new_bytearray_by_ref(len, items);
|
||||
}
|
||||
#endif
|
||||
} else {
|
||||
// Single index rather than slice.
|
||||
size_t index = mp_get_index(self->base.type, self->len, index_in, false);
|
||||
if (value == MP_OBJ_SENTINEL) {
|
||||
// load
|
||||
uint8_t value_out;
|
||||
common_hal_nvm_bytearray_get_bytes(self, index, 1, &value_out);
|
||||
return MP_OBJ_NEW_SMALL_INT(value_out);
|
||||
} else {
|
||||
// store
|
||||
mp_int_t byte_value = mp_obj_get_int(value);
|
||||
if (byte_value > 0xff || byte_value < 0) {
|
||||
mp_raise_ValueError("Bytes must be between 0 and 255.");
|
||||
}
|
||||
uint8_t short_value = byte_value;
|
||||
if (!common_hal_nvm_bytearray_set_bytes(self, index, &short_value, 1)) {
|
||||
mp_raise_RuntimeError("Unable to write to nvm.");
|
||||
}
|
||||
return mp_const_none;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const mp_obj_type_t nvm_bytearray_type = {
|
||||
{ &mp_type_type },
|
||||
.name = MP_QSTR_ByteArray,
|
||||
.make_new = nvm_bytearray_make_new,
|
||||
.subscr = nvm_bytearray_subscr,
|
||||
.unary_op = nvm_bytearray_unary_op,
|
||||
.print = NULL,
|
||||
.locals_dict = (mp_obj_t)&nvm_bytearray_locals_dict,
|
||||
};
|
||||
@ -0,0 +1,43 @@
|
||||
/*
|
||||
* This file is part of the Micro Python project, http://micropython.org/
|
||||
*
|
||||
* The MIT License (MIT)
|
||||
*
|
||||
* Copyright (c) 2017 Scott Shawcroft for Adafruit Industries
|
||||
*
|
||||
* 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_SHARED_BINDINGS_NVM_BYTEARRAY_H__
|
||||
#define __MICROPY_INCLUDED_SHARED_BINDINGS_NVM_BYTEARRAY_H__
|
||||
|
||||
#include "common-hal/nvm/ByteArray.h"
|
||||
|
||||
const mp_obj_type_t nvm_bytearray_type;
|
||||
|
||||
uint32_t common_hal_nvm_bytearray_get_length(nvm_bytearray_obj_t *self);
|
||||
|
||||
bool common_hal_nvm_bytearray_set_bytes(nvm_bytearray_obj_t *self,
|
||||
uint32_t start_index, uint8_t* values, uint32_t len);
|
||||
// len and values are intentionally swapped to signify values is an output and
|
||||
// also leverage the compiler to validate uses are expected.
|
||||
void common_hal_nvm_bytearray_get_bytes(nvm_bytearray_obj_t *self,
|
||||
uint32_t start_index, uint32_t len, uint8_t* values);
|
||||
|
||||
#endif // __MICROPY_INCLUDED_SHARED_BINDINGS_NVM_BYTEARRAY_H__
|
||||
@ -0,0 +1,62 @@
|
||||
/*
|
||||
* This file is part of the MicroPython project, http://micropython.org/
|
||||
*
|
||||
* The MIT License (MIT)
|
||||
*
|
||||
* Copyright (c) 2017 Scott Shawcroft for Adafruit Industries
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
* THE SOFTWARE.
|
||||
*/
|
||||
|
||||
#include "py/obj.h"
|
||||
#include "py/mphal.h"
|
||||
#include "py/runtime.h"
|
||||
|
||||
#include "shared-bindings/nvm/__init__.h"
|
||||
#include "shared-bindings/nvm/ByteArray.h"
|
||||
|
||||
//| :mod:`nvm` --- Non-volatile memory
|
||||
//| ===========================================================
|
||||
//|
|
||||
//| .. module:: nvm
|
||||
//| :synopsis: Non-volatile memory
|
||||
//| :platform: SAMD21
|
||||
//|
|
||||
//| The `nvm` module allows you to store whatever raw bytes you wish in a
|
||||
//| reserved section non-volatile memory.
|
||||
//|
|
||||
|
||||
//| Libraries
|
||||
//|
|
||||
//| .. toctree::
|
||||
//| :maxdepth: 3
|
||||
//|
|
||||
//| ByteArray
|
||||
STATIC const mp_rom_map_elem_t nvm_module_globals_table[] = {
|
||||
{ MP_ROM_QSTR(MP_QSTR___name__), MP_OBJ_NEW_QSTR(MP_QSTR_nvm) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_ByteArray), MP_ROM_PTR(&nvm_bytearray_type) },
|
||||
};
|
||||
|
||||
STATIC MP_DEFINE_CONST_DICT(nvm_module_globals, nvm_module_globals_table);
|
||||
|
||||
// cpy prefix is used to prevent collision with nvm_module global in ASF.
|
||||
const mp_obj_module_t cpy_nvm_module = {
|
||||
.base = { &mp_type_module },
|
||||
.globals = (mp_obj_dict_t*)&nvm_module_globals,
|
||||
};
|
||||
@ -0,0 +1,30 @@
|
||||
/*
|
||||
* This file is part of the MicroPython project, http://micropython.org/
|
||||
*
|
||||
* The MIT License (MIT)
|
||||
*
|
||||
* Copyright (c) 2017 Scott Shawcroft for Adafruit Industries
|
||||
*
|
||||
* 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 SHARED_BINDINGS_NVM_H
|
||||
#define SHARED_BINDINGS_NVM_H
|
||||
|
||||
#endif // SHARED_BINDINGS_NVM_H
|
||||
@ -0,0 +1,6 @@
|
||||
import skip_if
|
||||
skip_if.board_not_in("gemma_m0", "trinket_m0")
|
||||
|
||||
import microcontroller
|
||||
|
||||
assert(microcontroller.nvm == None)
|
||||
@ -0,0 +1,22 @@
|
||||
import skip_if
|
||||
skip_if.board_not_in("metro_m0_express", "feather_m0_express", "circuitplayground_express")
|
||||
|
||||
import microcontroller
|
||||
import random
|
||||
nvm = microcontroller.nvm
|
||||
|
||||
len(nvm)
|
||||
|
||||
single = random.randint(0, 255)
|
||||
nvm[1] = single
|
||||
assert(nvm[1] == single)
|
||||
|
||||
nvm[0] = single
|
||||
assert(nvm[0] == single)
|
||||
|
||||
b = bytearray()
|
||||
for i in range(10):
|
||||
b.append(random.randint(0, 255))
|
||||
|
||||
microcontroller.nvm[10:20] = b
|
||||
assert(microcontroller.nvm[10:20] == b)
|
||||
Loading…
Reference in New Issue