Class: ESP32::NVS

Inherits:
Object
  • Object
show all
Defined in:
src/nvs.c,
mrblib/nvs.rb

Overview

ESP-IDF Non-volatile storage library wrapper class.

c.f. Non-volatile storage library documentation

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize ⇒ Object

Examples:

open_mode = ESP32::NVS::READWRITE
ESP32::NVS.new("name", open_mode)
ESP32::NVS.new("part name", "name", open_mode)


116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
 
# File 'src/nvs.c', line 116

static mrb_value mrb_esp32_nvs_init(mrb_state *mrb, mrb_value self) {
  mrb_value part_name, name, open_mode;
  if (mrb_get_args(mrb, "oo|o", &part_name, &name, &open_mode) == 2) {
    open_mode = name;
    name = part_name;
    part_name = mrb_const_get(mrb, mrb_obj_value(mrb_class_get_under(mrb, mrb_module_get(mrb, "ESP32"), "NVS")), mrb_intern_lit(mrb, "DEFAULT_PART_NAME"));
  }

  if (!mrb_string_p(part_name)) {
    mrb_raise(mrb, E_ARGUMENT_ERROR, "part_name should be a string");
  }

  if (!mrb_string_p(name)) {
    mrb_raise(mrb, E_ARGUMENT_ERROR, "name should be a string");
  }

  if (!mrb_fixnum_p(open_mode)) {
    mrb_raise(mrb, E_ARGUMENT_ERROR, "opt_mode should be a integer");
  }

  nvs_handle out_handle;
  esp_err_t err = nvs_open_from_partition(RSTRING_PTR(part_name), RSTRING_PTR(name), (nvs_open_mode)mrb_fixnum(open_mode), &out_handle);
  if (err != ESP_OK) {
    mrb_raise_esp32_err(mrb, err);
  }

  mrb_data_init(self, (void *)out_handle, &mrb_esp32_nvs_type);

  return self;
}

Class Method Details

.open(part_name = ESP32::NVS::DEFAULT_PART_NAME, name, open_mode) ⇒ Object

Examples:

Write values

ESP32::NVS.open("namespace", ESP32::NVS::READWRITE) do |nvs|
  nvs.set_i8("8", 8)
  nvs.set_i16("16", 16)
  nvs.set_i32("32", 32)
  nvs.set_i64("64", 64) # depends on MRB_INT_BIT
  nvs.set_str("str", "STR")
  nvs.set_blob("blob", "BLOB")
end

Read values

ESP32::NVS.open("namespace", ESP32::NVS::READONLY) do |nvs|
  nvs.get_i8("8")
  nvs.get_i16("16")
  nvs.get_i32("32")
  nvs.get_i64("64") # depends on MRB_INT_BIT
  nvs.get_str("str")
  nvs.get_blob("blob")
end

Read value from different partition

ESP32::NVS.open("music", "bgm", ESP32::NVS::READONLY) do |nvs|
  nvs.get_blob("1.mp3")
end


27
28
29
30
31
32
33
34
35
 
# File 'mrblib/nvs.rb', line 27

def self.open(part_name = ESP32::NVS::DEFAULT_PART_NAME, name, open_mode)
  nvs = new(part_name, name, open_mode)
  begin
    yield nvs
    nvs.commit
  ensure
    nvs.close
  end
end

Instance Method Details

#close ⇒ Object

Examples:

nvs.close


432
433
434
435
436
 
# File 'src/nvs.c', line 432

static mrb_value mrb_esp32_nvs_close(mrb_state *mrb, mrb_value self) {
  nvs_handle handle = (nvs_handle)DATA_PTR(self);
  nvs_close(handle);
  return mrb_nil_value();
}

#commit ⇒ Object

Examples:

nvs.commit


418
419
420
421
422
423
424
425
426
 
# File 'src/nvs.c', line 418

static mrb_value mrb_esp32_nvs_commit(mrb_state *mrb, mrb_value self) {
  nvs_handle handle = (nvs_handle)DATA_PTR(self);
  esp_err_t err = nvs_commit(handle);
  if (err != ESP_OK) {
    mrb_raise_esp32_err(mrb, err);
  }

  return mrb_nil_value();
}

#erase_all ⇒ Object

Examples:

nvs.erase_all


404
405
406
407
408
409
410
411
412
 
# File 'src/nvs.c', line 404

static mrb_value mrb_esp32_nvs_erase_all(mrb_state *mrb, mrb_value self) {
  nvs_handle handle = (nvs_handle)DATA_PTR(self);
  esp_err_t err = nvs_erase_all(handle);
  if (err != ESP_OK) {
    mrb_raise_esp32_err(mrb, err);
  }

  return mrb_nil_value();
}

#erase_key ⇒ Object

Examples:

nvs.erase_key("key")


387
388
389
390
391
392
393
394
395
396
397
398
 
# File 'src/nvs.c', line 387

static mrb_value mrb_esp32_nvs_erase_key(mrb_state *mrb, mrb_value self) {
  char *key;
  mrb_get_args(mrb, "z", &key);

  nvs_handle handle = (nvs_handle)DATA_PTR(self);
  esp_err_t err = nvs_erase_key(handle, key);
  if (err != ESP_OK) {
    mrb_raise_esp32_err(mrb, err);
  }

  return mrb_nil_value();
}

#get_blob ⇒ Object

Examples:

nvs.get_blob("key")


363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
 
# File 'src/nvs.c', line 363

static mrb_value mrb_esp32_nvs_get_blob(mrb_state *mrb, mrb_value self) {
  char *key;
  mrb_get_args(mrb, "z", &key);

  nvs_handle handle = (nvs_handle)DATA_PTR(self);
  size_t length;
  esp_err_t err = nvs_get_blob(handle, key, NULL, &length);
  if (err != ESP_OK) {
    mrb_raise_esp32_err(mrb, err);
  }

  mrb_value str = mrb_str_new(mrb, NULL, length);
  err = nvs_get_blob(handle, key, RSTRING_PTR(str), &length);
  if (err != ESP_OK) {
    mrb_raise_esp32_err(mrb, err);
  }

  return str;
}

#get_i16 ⇒ Object

Examples:

nvs.get_i16("key")


208
209
210
211
212
213
214
215
216
217
218
219
220
 
# File 'src/nvs.c', line 208

static mrb_value mrb_esp32_nvs_get_i16(mrb_state *mrb, mrb_value self) {
  char *key;
  mrb_get_args(mrb, "z", &key);

  nvs_handle handle = (nvs_handle)DATA_PTR(self);
  int16_t out_value;
  esp_err_t err = nvs_get_i16(handle, key, &out_value);
  if (err != ESP_OK) {
    mrb_raise_esp32_err(mrb, err);
  }

  return mrb_fixnum_value((mrb_int)out_value);
}

#get_i32 ⇒ Object

Examples:

nvs.get_i32("key")


246
247
248
249
250
251
252
253
254
255
256
257
258
 
# File 'src/nvs.c', line 246

static mrb_value mrb_esp32_nvs_get_i32(mrb_state *mrb, mrb_value self) {
  char *key;
  mrb_get_args(mrb, "z", &key);

  nvs_handle handle = (nvs_handle)DATA_PTR(self);
  int32_t out_value;
  esp_err_t err = nvs_get_i32(handle, key, &out_value);
  if (err != ESP_OK) {
    mrb_raise_esp32_err(mrb, err);
  }

  return mrb_fixnum_value((mrb_int)out_value);
}

#get_i64 ⇒ Object

Examples:

nvs.get_i64("key")


284
285
286
287
288
289
290
291
292
293
294
295
296
 
# File 'src/nvs.c', line 284

static mrb_value mrb_esp32_nvs_get_i64(mrb_state *mrb, mrb_value self) {
  char *key;
  mrb_get_args(mrb, "z", &key);

  nvs_handle handle = (nvs_handle)DATA_PTR(self);
  int64_t out_value;
  esp_err_t err = nvs_get_i64(handle, key, &out_value);
  if (err != ESP_OK) {
    mrb_raise_esp32_err(mrb, err);
  }

  return mrb_fixnum_value((mrb_int)out_value);
}

#get_i8 ⇒ Object

Examples:

nvs.get_i8("key")


170
171
172
173
174
175
176
177
178
179
180
181
182
 
# File 'src/nvs.c', line 170

static mrb_value mrb_esp32_nvs_get_i8(mrb_state *mrb, mrb_value self) {
  char *key;
  mrb_get_args(mrb, "z", &key);

  nvs_handle handle = (nvs_handle)DATA_PTR(self);
  int8_t out_value;
  esp_err_t err = nvs_get_i8(handle, key, &out_value);
  if (err != ESP_OK) {
    mrb_raise_esp32_err(mrb, err);
  }

  return mrb_fixnum_value((mrb_int)out_value);
}

#get_str ⇒ Object

Examples:

nvs.get_str("key")


321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
 
# File 'src/nvs.c', line 321

static mrb_value mrb_esp32_nvs_get_str(mrb_state *mrb, mrb_value self) {
  char *key;
  mrb_get_args(mrb, "z", &key);

  nvs_handle handle = (nvs_handle)DATA_PTR(self);
  size_t length;
  esp_err_t err = nvs_get_str(handle, key, NULL, &length);
  if (err != ESP_OK) {
    mrb_raise_esp32_err(mrb, err);
  }

  mrb_value str = mrb_str_new(mrb, NULL, length);
  err = nvs_get_str(handle, key, RSTRING_PTR(str), &length);
  if (err != ESP_OK) {
    mrb_raise_esp32_err(mrb, err);
  }

  return str;
}

#set_blob ⇒ Object

Examples:

nvs.set_blob("key", "hi")


345
346
347
348
349
350
351
352
353
354
355
356
357
 
# File 'src/nvs.c', line 345

static mrb_value mrb_esp32_nvs_set_blob(mrb_state *mrb, mrb_value self) {
  char *key;
  mrb_value value;
  mrb_get_args(mrb, "zS", &key, &value);

  nvs_handle handle = (nvs_handle)DATA_PTR(self);
  esp_err_t err = nvs_set_blob(handle, key, RSTRING_PTR(value), RSTRING_LEN(value));
  if (err != ESP_OK) {
    mrb_raise_esp32_err(mrb, err);
  }

  return value;
}

#set_i16 ⇒ Object

Examples:

nvs.set_i16("key", 42)


190
191
192
193
194
195
196
197
198
199
200
201
202
 
# File 'src/nvs.c', line 190

static mrb_value mrb_esp32_nvs_set_i16(mrb_state *mrb, mrb_value self) {
  char *key;
  mrb_int value;
  mrb_get_args(mrb, "zi", &key, &value);

  nvs_handle handle = (nvs_handle)DATA_PTR(self);
  esp_err_t err = nvs_set_i16(handle, key, (int16_t)value);
  if (err != ESP_OK) {
    mrb_raise_esp32_err(mrb, err);
  }

  return mrb_fixnum_value(value);
}

#set_i32 ⇒ Object

Examples:

nvs.set_i32("key", 42)


228
229
230
231
232
233
234
235
236
237
238
239
240
 
# File 'src/nvs.c', line 228

static mrb_value mrb_esp32_nvs_set_i32(mrb_state *mrb, mrb_value self) {
  char *key;
  mrb_int value;
  mrb_get_args(mrb, "zi", &key, &value);

  nvs_handle handle = (nvs_handle)DATA_PTR(self);
  esp_err_t err = nvs_set_i32(handle, key, (int32_t)value);
  if (err != ESP_OK) {
    mrb_raise_esp32_err(mrb, err);
  }

  return mrb_fixnum_value(value);
}

#set_i64 ⇒ Object

Examples:

nvs.set_i64("key", 42)


266
267
268
269
270
271
272
273
274
275
276
277
278
 
# File 'src/nvs.c', line 266

static mrb_value mrb_esp32_nvs_set_i64(mrb_state *mrb, mrb_value self) {
  char *key;
  mrb_int value;
  mrb_get_args(mrb, "zi", &key, &value);

  nvs_handle handle = (nvs_handle)DATA_PTR(self);
  esp_err_t err = nvs_set_i64(handle, key, (int64_t)value);
  if (err != ESP_OK) {
    mrb_raise_esp32_err(mrb, err);
  }

  return mrb_fixnum_value(value);
}

#set_i8 ⇒ Object

Examples:

nvs.set_i8("key", 42)


152
153
154
155
156
157
158
159
160
161
162
163
164
 
# File 'src/nvs.c', line 152

static mrb_value mrb_esp32_nvs_set_i8(mrb_state *mrb, mrb_value self) {
  char *key;
  mrb_int value;
  mrb_get_args(mrb, "zi", &key, &value);

  nvs_handle handle = (nvs_handle)DATA_PTR(self);
  esp_err_t err = nvs_set_i8(handle, key, (int8_t)value);
  if (err != ESP_OK) {
    mrb_raise_esp32_err(mrb, err);
  }

  return mrb_fixnum_value(value);
}

#set_str ⇒ Object

Examples:

nvs.set_str("key", "hi")


303
304
305
306
307
308
309
310
311
312
313
314
315
 
# File 'src/nvs.c', line 303

static mrb_value mrb_esp32_nvs_set_str(mrb_state *mrb, mrb_value self) {
  char *key;
  mrb_value value;
  mrb_get_args(mrb, "zS", &key, &value);

  nvs_handle handle = (nvs_handle)DATA_PTR(self);
  esp_err_t err = nvs_set_str(handle, key, RSTRING_PTR(value));
  if (err != ESP_OK) {
    mrb_raise_esp32_err(mrb, err);
  }

  return value;
}