symbols.json

[
  {
    "name": "mgos_app_init",
    "file": "[mgos_app.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_app.h)",
    "doc": "\n```c\nenum mgos_app_init_result mgos_app_init(void);\n```\n> \n> User app init function.\n> A weak stub is provided in `mgos_app_init.c`, which can be overridden.\n> \n> Example of a user-defined init function:\n> ```c\n> #include \"mgos_app.h\"\n> \n> enum mgos_app_init_result mgos_app_init(void) {\n>   if (!my_super_duper_hardware_init()) {\n>     LOG(LL_ERROR, (\"something went bad\"));\n>     return MGOS_APP_INIT_ERROR;\n>   }\n>   LOG(LL_INFO, (\"my app initialised\"));\n>   return MGOS_APP_INIT_SUCCESS;\n> }\n> ```\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_app_preinit",
    "file": "[mgos_app.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_app.h)",
    "doc": "\n```c\nvoid mgos_app_preinit(void);\n```\n> \n> An early init hook, for apps that want to take control early\n> in the init process. How early? very, very early. If the platform\n> uses RTOS, it is not running yet. Dynamic memory allocation is not\n> safe. Networking is not running. The only safe thing to do is to\n> communicate to mg_app_init something via global variables or shut\n> down the processor and go (back) to sleep.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_bitbang_write_bits",
    "file": "[mgos_bitbang.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_bitbang.h)",
    "doc": "\n```c\nvoid mgos_bitbang_write_bits(int gpio, enum mgos_delay_unit delay_unit, int t0h,\n                             int t0l, int t1h, int t1l, const uint8_t *data,\n                             size_t len);\n```\n> \n> Bit bang GPIO pin `gpio`. `len` bytes from `data` are sent to the specified\n> pin bit by bit. Sending each bit consists of a \"high\" and \"low\" phases,\n> length of which is determined by the specified timing parameters.\n> \n> ```\n>  +-----+\n>  |     |\n> -+     +-------\n> \n>  tXh   tXl\n> ```\n> \n> `t0h` and `t0l` specify timings if the bit being transmitted is 0,\n> `t1h` and `t1l` specify the same for the case where the bit is 1.\n> If any of these is < 0, the corresponding phase is skipped.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_bitbang_write_bits_js",
    "file": "[mgos_bitbang.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_bitbang.h)",
    "doc": "\n```c\nvoid mgos_bitbang_write_bits_js(int gpio, enum mgos_delay_unit delay_unit,\n                                uint32_t t, const uint8_t *data, size_t len);\n```\n> \n> This function is a wrapper for `mgos_bitbang_write_bits()`.\n> It has smaller number of arguments (less than 6) and therefore could be\n> FFI-ed to JavaScript. Essentially, it just packs all time patterns\n> into a single value `t`.\n>  \n",
    "lang": "c"
  },
  {
    "name": "BitBang.write(pin, delay_unit, t0h, t0l, t1h, t1l, ptr, len)",
    "file": "[api_bitbang.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_bitbang.js)",
    "doc": "\n```javascript\nBitBang.write(pin, delay_unit, t0h, t0l, t1h, t1l, ptr, len)\n```\nWrite bits to a given `pin`. `delay_unit` is one of the:\n`BitBang.DELAY_MSEC`, `BitBang.DELAY_USEC`, `BitBang.DELAY_100NSEC`.\n`ptr, len` is a bit pattern to write. `t0h, t0l` is the time pattern\nfor zero bit, `t1h, t1l` is the time pattern for 1. The time pattern\nspecifies the number of time units to hold the pin high, and the number\nof units to hold the pin low. Return value: none.\n",
    "lang": "js"
  },
  {
    "name": "mgos_debug_write",
    "file": "[mgos_debug.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_debug.h)",
    "doc": "\n```c\nvoid mgos_debug_write(int fd, const void *buf, size_t len);\n```\n> \n> Write debug info `buf`, `len` to the given file descriptor `fd`.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_debug_flush",
    "file": "[mgos_debug.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_debug.h)",
    "doc": "\n```c\nvoid mgos_debug_flush(void);\n```\n> \n> Flush debug UARTs, both stdout and stderr.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_set_stdout_uart",
    "file": "[mgos_debug.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_debug.h)",
    "doc": "\n```c\nenum mgos_init_result mgos_set_stdout_uart(int uart_no);\n```\n>  Set UART for stdout. Negative value disables stdout. \n",
    "lang": "c"
  },
  {
    "name": "mgos_set_stderr_uart",
    "file": "[mgos_debug.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_debug.h)",
    "doc": "\n```c\nenum mgos_init_result mgos_set_stderr_uart(int uart_no);\n```\n>  Set UART for stderr. Negative value disables stderr. \n",
    "lang": "c"
  },
  {
    "name": "mgos_get_stdout_uart",
    "file": "[mgos_debug.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_debug.h)",
    "doc": "\n```c\nint mgos_get_stdout_uart(void);\n```\n>  Get stdout UART number; -1 indicates that stdout is disabled. \n",
    "lang": "c"
  },
  {
    "name": "mgos_get_stderr_uart",
    "file": "[mgos_debug.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_debug.h)",
    "doc": "\n```c\nint mgos_get_stderr_uart(void);\n```\n>  Get stderr UART number; -1 indicates that stderr is disabled. \n",
    "lang": "c"
  },
  {
    "name": "mgos_debug_suspend_uart",
    "file": "[mgos_debug.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_debug.h)",
    "doc": "\n```c\nvoid mgos_debug_suspend_uart(void);\n```\n> \n> Suspend UART output (both stdout and stderr); see\n> `mgos_debug_resume_uart()`. Nested suspension is supported: UART needs to be\n> resumed as many times as it was suspended.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_debug_resume_uart",
    "file": "[mgos_debug.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_debug.h)",
    "doc": "\n```c\nvoid mgos_debug_resume_uart(void);\n```\n> \n> Resume previously suspended UART output, see `mgos_debug_suspend_uart()`.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_debug_uart_is_suspended",
    "file": "[mgos_debug.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_debug.h)",
    "doc": "\n```c\nbool mgos_debug_uart_is_suspended(void);\n```\n> \n> Returns whether UART output is suspended at the moment.\n>  \n",
    "lang": "c"
  },
  {
    "name": "Log.print(level, msg)",
    "file": "[api_log.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_log.js)",
    "doc": "\n```javascript\nLog.print(level, msg)\n```\nPrint message to stderr if provided\nlevel is >= `Cfg.get('debug.level')`. Possible levels are:\n- `Log.ERROR` (0)\n- `Log.WARN` (1)\n- `Log.INFO` (2)\n- `Log.DEBUG` (3)\n- `Log.VERBOSE_DEBUG` (4)\n",
    "lang": "js"
  },
  {
    "name": "Log.error(msg)",
    "file": "[api_log.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_log.js)",
    "doc": "\n```javascript\nLog.error(msg)\n```\nShortcut for `Log.print(Log.ERROR, msg)`\n",
    "lang": "js"
  },
  {
    "name": "Log.warn(msg)",
    "file": "[api_log.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_log.js)",
    "doc": "\n```javascript\nLog.warn(msg)\n```\nShortcut for `Log.print(Log.WARN, msg)`\n",
    "lang": "js"
  },
  {
    "name": "Log.info(msg)",
    "file": "[api_log.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_log.js)",
    "doc": "\n```javascript\nLog.info(msg)\n```\nShortcut for `Log.print(Log.INFO, msg)`\n",
    "lang": "js"
  },
  {
    "name": "Log.debug(msg)",
    "file": "[api_log.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_log.js)",
    "doc": "\n```javascript\nLog.debug(msg)\n```\nShortcut for `Log.print(Log.DEBUG, msg)`\n",
    "lang": "js"
  },
  {
    "name": "Log.verboseDebug(msg)",
    "file": "[api_log.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_log.js)",
    "doc": "\n```javascript\nLog.verboseDebug(msg)\n```\nShortcut for `Log.print(Log.VERBOSE_DEBUG, msg)`\n",
    "lang": "js"
  },
  {
    "name": "MGOS_EVENT_BASE",
    "file": "[mgos_event.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_event.h)",
    "doc": "\n```c\n#define MGOS_EVENT_BASE(a, b, c) ((a) << 24 | (b) << 16 | (c) << 8)\n```\n> \n> Macro to generate unique base event number.\n> A library can use the last byte (LSB) to create up to 256 unique\n> events (see enum below on how Mongoose OS core defines its events).\n> A library should call mgos_event_register_base() in order to claim\n> it and prevent event number conflicts.\n>  \n",
    "lang": "c"
  },
  {
    "name": "MGOS_EVENT_BASE",
    "file": "[mgos_event.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_event.h)",
    "doc": "\n```c\n#define MGOS_EVENT_SYS MGOS_EVENT_BASE('M', 'O', 'S')\n```\n> \n> These events are registered by the MGOS core.\n> Other events could be registered by the external libraries.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_event_register_base",
    "file": "[mgos_event.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_event.h)",
    "doc": "\n```c\nbool mgos_event_register_base(int base_event_number, const char *name);\n```\n> \n> Register a base event number in order to prevent event number conflicts.\n> Use `MGOS_EVENT_BASE()` macro to get `base_event_number`; `name` is an\n> arbitrary name of the module who registers the base number.\n> \n> Example:\n> ```c\n> #define MY_EVENT_BASE MGOS_EVENT_BASE('F', 'O', 'O')\n> \n> enum my_event {\n>   MY_EVENT_AAA = MY_EVENT_BASE,\n>   MY_EVENT_BBB,\n>   MY_EVENT_CCC,\n> };\n> \n> // And somewhere else:\n> mgos_event_register_base(MY_EVENT_BASE, \"my module foo\");\n> ```\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_event_trigger",
    "file": "[mgos_event.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_event.h)",
    "doc": "\n```c\nint mgos_event_trigger(int ev, void *ev_data);\n```\n>  Trigger an event `ev` with the event data `ev_data`. Return number of event\n> handlers invoked. \n",
    "lang": "c"
  },
  {
    "name": "(*mgos_event_handler_t)",
    "file": "[mgos_event.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_event.h)",
    "doc": "\n```c\ntypedef void (*mgos_event_handler_t)(int ev, void *ev_data, void *userdata);\n```\n>  Event handler signature. \n",
    "lang": "c"
  },
  {
    "name": "mgos_event_add_handler",
    "file": "[mgos_event.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_event.h)",
    "doc": "\n```c\nbool mgos_event_add_handler(int ev, mgos_event_handler_t cb, void *userdata);\n```\n> \n> Add an event handler. Return true on success, false on error (e.g. OOM).\n> \n> Example:\n> ```c\n> static void system_restart_cb(int ev, void *ev_data, void *userdata) {\n>   LOG(LL_INFO, (\"Going to reboot!\"));\n>   (void) ev;\n>   (void) ev_data;\n>   (void) userdata;\n> }\n> \n> // And somewhere else:\n> mgos_event_add_handler(MGOS_EVENT_REBOOT, system_restart_cb, NULL);\n> ```\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_event_add_group_handler",
    "file": "[mgos_event.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_event.h)",
    "doc": "\n```c\nbool mgos_event_add_group_handler(int evgrp, mgos_event_handler_t cb,\n                                  void *userdata);\n```\n> \n> Like `mgos_event_add_handler()`, but subscribes on all events in the given\n> group `evgrp`. Event group includes all events from `evgrp & ~0xff` to\n> `evgrp | 0xff`.\n> \n> Example:\n> ```c\n> static void sys_event_cb(int ev, void *ev_data, void *userdata) {\n>   LOG(LL_INFO, (\"Got system event %d\", ev));\n>   (void) ev;\n>   (void) ev_data;\n>   (void) userdata;\n> }\n> \n> // And somewhere else:\n> mgos_event_add_handler(MGOS_EVENT_SYS, sys_event_cb, NULL);\n> ```\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_event_remove_handler",
    "file": "[mgos_event.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_event.h)",
    "doc": "\n```c\nbool mgos_event_remove_handler(int ev, mgos_event_handler_t cb, void *userdata);\nbool mgos_event_remove_group_handler(int evgrp, mgos_event_handler_t cb,\n                                     void *userdata);\n```\n> \n> Remove an event handler.\n> Both cb and userdata must match the initial add invocation.\n> Returns true if a handler was found and removed, false if there was no\n> such handler in the first place.\n>  \n",
    "lang": "c"
  },
  {
    "name": "Event.addHandler(ev, callback, userdata)",
    "file": "[api_events.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_events.js)",
    "doc": "\n```javascript\nEvent.addHandler(ev, callback, userdata)\n```\nAdd a handler for the given event `ev`. Callback should look like:\n\nfunction(ev, evdata, userdata) { /* ... */ }\n\nExample:\n```javascript\n\nEvent.addHandler(Event.REBOOT, function(ev, evdata, ud) {\n  print(\"Going to reboot!\");\n}, null);\n```\n",
    "lang": "js"
  },
  {
    "name": "Event.addGroupHandler(evgrp, callback, userdata)",
    "file": "[api_events.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_events.js)",
    "doc": "\n```javascript\nEvent.addGroupHandler(evgrp, callback, userdata)\n```\nLike `Event.addHandler()`, but subscribes on all events in the given\nevent group `evgrp`. Event group includes all events from `evgrp & ~0xff`\nto `evgrp | 0xff`.\n\nExample:\n```javascript\n\nEvent.addGroupHandler(Event.SYS, function(ev, evdata, ud) {\n  print(\"Sys event:\", ev);\n}, null);\n```\n",
    "lang": "js"
  },
  {
    "name": "Event.on(event_num, callback, userdata)",
    "file": "[api_events.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_events.js)",
    "doc": "\n```javascript\nEvent.on(event_num, callback, userdata)\n```\nAlias for Event.addHandler\n",
    "lang": "js"
  },
  {
    "name": "Event.regBase(base_event_number, name)",
    "file": "[api_events.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_events.js)",
    "doc": "\n```javascript\nEvent.regBase(base_event_number, name)\n```\nRegister a base event number in order to prevent event number conflicts.\nUse `Event.baseNumber(id)` to get `base_event_number`; `name` is an\narbitrary event name.\n\nExample:\n```javascript\nlet bn = Event.baseNumber(\"ABC\");\nif (!Event.regBase(bn, \"My module\")) {\n  die(\"Failed to register base event number\");\n}\n\nlet MY_EVENT_FOO = bn + 0;\nlet MY_EVENT_BAR = bn + 1;\nlet MY_EVENT_BAZ = bn + 2;\n```\n",
    "lang": "js"
  },
  {
    "name": "Event.baseNumber(id)",
    "file": "[api_events.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_events.js)",
    "doc": "\n```javascript\nEvent.baseNumber(id)\n```\nGenerates unique base event number (32-bit) by a 3-char string.\nLSB is always zero, and a library can use it to create up to 256 unique\nevents.\n\nA library should call `Event.regBase()` in order to claim\nit and prevent event number conflicts. (see example there)\n",
    "lang": "js"
  },
  {
    "name": "Event.trigger(ev, evdata)",
    "file": "[api_events.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_events.js)",
    "doc": "\n```javascript\nEvent.trigger(ev, evdata)\n```\nTrigger an event with the given id `ev` and event data `evdata`.\n",
    "lang": "js"
  },
  {
    "name": "Event.evdataLogStr(evdata)",
    "file": "[api_events.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_events.js)",
    "doc": "\n```javascript\nEvent.evdataLogStr(evdata)\n```\nGetter function for the `evdata` given to the event callback for the event\n`Event.LOG`, see `Event.addHandler()`.\n",
    "lang": "js"
  },
  {
    "name": "Event.LOG",
    "file": "[api_events.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_events.js)",
    "doc": "\n```javascript\nEvent.LOG\n```\nSystem event which is triggered every time something is printed to the\nlog.  In the callback, use `Event.evdataLogStr(evdata)` to get string\nwhich was printed.\n",
    "lang": "js"
  },
  {
    "name": "Event.REBOOT",
    "file": "[api_events.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_events.js)",
    "doc": "\n```javascript\nEvent.REBOOT\n```\nSystem event which is triggered right before going to reboot. `evdata`\nis irrelevant for this event.\n",
    "lang": "js"
  },
  {
    "name": "Event.OTA_STATUS",
    "file": "[api_events.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_events.js)",
    "doc": "\n```javascript\nEvent.OTA_STATUS\n```\nSystem event which is triggered when OTA status changes.\n\nIn the callback, use `OTA.evdataOtaStatusMsg(evdata)` from `api_ota.js` to\nget the OTA status message.\n",
    "lang": "js"
  },
  {
    "name": "Event.CLOUD_CONNECTED",
    "file": "[api_events.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_events.js)",
    "doc": "\n```javascript\nEvent.CLOUD_CONNECTED\n```\nTriggered when device is connected to the cloud (mqtt, dash)\n",
    "lang": "js"
  },
  {
    "name": "Event.CLOUD_DISCONNECTED",
    "file": "[api_events.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_events.js)",
    "doc": "\n```javascript\nEvent.CLOUD_DISCONNECTED\n```\nTriggered when device is disconnected from the cloud\n",
    "lang": "js"
  },
  {
    "name": "mgos_file_copy",
    "file": "[mgos_file_utils.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_file_utils.h)",
    "doc": "\n```c\nbool mgos_file_copy(const char *from, const char *to);\n```\n>  Copy a file \n",
    "lang": "c"
  },
  {
    "name": "mgos_file_digest",
    "file": "[mgos_file_utils.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_file_utils.h)",
    "doc": "\n```c\nbool mgos_file_digest(const char *fname, mbedtls_md_type_t dt, uint8_t *digest);\n```\n>  Compute file's digest. *digest must have enough space for the digest type. \n",
    "lang": "c"
  },
  {
    "name": "mgos_file_copy_if_different",
    "file": "[mgos_file_utils.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_file_utils.h)",
    "doc": "\n```c\nbool mgos_file_copy_if_different(const char *from, const char *to);\n```\n>  Copy the file if target does not exist or is different. \n",
    "lang": "c"
  },
  {
    "name": "(*mgos_gpio_int_handler_f)",
    "file": "[mgos_gpio.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_gpio.h)",
    "doc": "\n```c\ntypedef void (*mgos_gpio_int_handler_f)(int pin, void *arg);\n```\n>  GPIO interrupt handler signature. \n",
    "lang": "c"
  },
  {
    "name": "mgos_gpio_set_mode",
    "file": "[mgos_gpio.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_gpio.h)",
    "doc": "\n```c\nbool mgos_gpio_set_mode(int pin, enum mgos_gpio_mode mode);\n```\n>  Set mode - input or output. \n",
    "lang": "c"
  },
  {
    "name": "mgos_gpio_set_pull",
    "file": "[mgos_gpio.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_gpio.h)",
    "doc": "\n```c\nbool mgos_gpio_set_pull(int pin, enum mgos_gpio_pull_type pull);\n```\n>  Set pull-up or pull-down type. \n",
    "lang": "c"
  },
  {
    "name": "mgos_gpio_setup_input",
    "file": "[mgos_gpio.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_gpio.h)",
    "doc": "\n```c\nbool mgos_gpio_setup_input(int pin, enum mgos_gpio_pull_type pull);\n```\n>  Sets up a pin as an input and confiures pull-up or pull-down. \n",
    "lang": "c"
  },
  {
    "name": "mgos_gpio_setup_output",
    "file": "[mgos_gpio.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_gpio.h)",
    "doc": "\n```c\nbool mgos_gpio_setup_output(int pin, bool level);\n```\n> \n> Sets up pin output while avoiding spurious transitions:\n> desired output level is configured first, then mode.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_gpio_read",
    "file": "[mgos_gpio.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_gpio.h)",
    "doc": "\n```c\nbool mgos_gpio_read(int pin);\n```\n>  Read pin input level. \n",
    "lang": "c"
  },
  {
    "name": "mgos_gpio_write",
    "file": "[mgos_gpio.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_gpio.h)",
    "doc": "\n```c\nvoid mgos_gpio_write(int pin, bool level);\n```\n>  Set pin's output level. \n",
    "lang": "c"
  },
  {
    "name": "mgos_gpio_toggle",
    "file": "[mgos_gpio.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_gpio.h)",
    "doc": "\n```c\nbool mgos_gpio_toggle(int pin);\n```\n>  Flip output pin value. Returns value that was written. \n",
    "lang": "c"
  },
  {
    "name": "mgos_gpio_read_out",
    "file": "[mgos_gpio.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_gpio.h)",
    "doc": "\n```c\nbool mgos_gpio_read_out(int pin);\n```\n>  Read the value of the output register. \n",
    "lang": "c"
  },
  {
    "name": "mgos_gpio_set_int_handler",
    "file": "[mgos_gpio.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_gpio.h)",
    "doc": "\n```c\nbool mgos_gpio_set_int_handler(int pin, enum mgos_gpio_int_mode mode,\n                               mgos_gpio_int_handler_f cb, void *arg);\n```\n> \n> Install a GPIO interrupt handler.\n> \n> This will invoke handler on the main task, which makes it possible to use\n> any functions but may delay servicing of the interrupt. If lower latency\n> is required, use `mgos_gpio_set_int_handler_isr`, but you'll need to\n> understand the implications, which are platform-specific.\n> \n> Interrupt is automatically cleared once upon triggering.\n> Then it is disabled until the handler gets a chance to run, at which point\n> it is re-enabled. At this point it may re-trigger immediately if the\n> interrupt condition arose again while the handler was pending or running.\n> Handler may use `mgos_gpio_clear_int` to explicitly clear the condition.\n> \n> Note that this will not enable the interrupt, this must be done explicitly\n> with `mgos_gpio_enable_int()`.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_gpio_set_int_handler_isr",
    "file": "[mgos_gpio.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_gpio.h)",
    "doc": "\n```c\nbool mgos_gpio_set_int_handler_isr(int pin, enum mgos_gpio_int_mode mode,\n                                   mgos_gpio_int_handler_f cb, void *arg);\n```\n> \n> Same as mgos_gpio_set_int_handler but invokes handler in ISR context,\n> without the overhead of a context switch. GPIO interrupts are disabled while\n> the handler is running.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_gpio_enable_int",
    "file": "[mgos_gpio.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_gpio.h)",
    "doc": "\n```c\nbool mgos_gpio_enable_int(int pin);\n```\n>  Enable interrupt on the specified pin. \n",
    "lang": "c"
  },
  {
    "name": "mgos_gpio_disable_int",
    "file": "[mgos_gpio.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_gpio.h)",
    "doc": "\n```c\nbool mgos_gpio_disable_int(int pin);\n```\n>  Disables interrupt (without removing the handler). \n",
    "lang": "c"
  },
  {
    "name": "mgos_gpio_clear_int",
    "file": "[mgos_gpio.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_gpio.h)",
    "doc": "\n```c\nvoid mgos_gpio_clear_int(int pin);\n```\n>  Clears a GPIO interrupt flag. \n",
    "lang": "c"
  },
  {
    "name": "mgos_gpio_remove_int_handler",
    "file": "[mgos_gpio.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_gpio.h)",
    "doc": "\n```c\nvoid mgos_gpio_remove_int_handler(int pin, mgos_gpio_int_handler_f *old_cb,\n                                  void **old_arg);\n```\n> \n> Removes a previosuly set interrupt handler.\n> \n> If `cb` and `arg` are not NULL, they will contain previous handler and arg.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_gpio_set_button_handler",
    "file": "[mgos_gpio.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_gpio.h)",
    "doc": "\n```c\nbool mgos_gpio_set_button_handler(int pin, enum mgos_gpio_pull_type pull_type,\n                                  enum mgos_gpio_int_mode int_mode,\n                                  int debounce_ms, mgos_gpio_int_handler_f cb,\n                                  void *arg);\n```\n> \n> Handle a button on the specified pin.\n> \n> Configures the pin for input with specified pull-up and performs debouncing:\n> upon first triggering user's callback is invoked immediately but further\n> interrupts are inhibited for the following debounce_ms millseconds.\n> \n> Typically 50 ms of debouncing time is sufficient.\n> int_mode is one of the `MGOS_GPIO_INT_EDGE_*` values and will specify whether\n> the handler triggers when button is pressed, released or both.\n> Which is which depends on how the button is wired: if the normal state is\n> pull-up (typical), then `MGOS_GPIO_INT_EDGE_NEG` is press and\n> `_POS` is release.\n> \n> Calling with `cb` = NULL will remove a previously installed handler.\n> \n> Note: implicitly enables the interrupt.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_gpio_blink",
    "file": "[mgos_gpio.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_gpio.h)",
    "doc": "\n```c\nbool mgos_gpio_blink(int pin, int on_ms, int off_ms);\n```\n> \n> A utility function that takes care of blinking an LED.\n> The pin must be configured as output first.\n> On (output \"1\") and off (\"0\") times are specified in milliseconds.\n> Set to (0, 0) to disable.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_gpio_str",
    "file": "[mgos_gpio.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_gpio.h)",
    "doc": "\n```c\nconst char *mgos_gpio_str(int pin_def, char buf[8]);\n```\n>  String representation of pin number.\n> Will return \"PA5\" or \"PK3\" for platforms that have port banks. \n",
    "lang": "c"
  },
  {
    "name": "GPIO.set_mode(pin, mode)",
    "file": "[api_gpio.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_gpio.js)",
    "doc": "\n```javascript\nGPIO.set_mode(pin, mode)\n```\nSet GPIO pin mode.\n`mode` can be either `GPIO.MODE_INPUT` or `GPIO.MODE_OUTPUT`.\n",
    "lang": "js"
  },
  {
    "name": "GPIO.set_pull(pin, pull_type)",
    "file": "[api_gpio.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_gpio.js)",
    "doc": "\n```javascript\nGPIO.set_pull(pin, pull_type)\n```\nSet GPIO pin pull type.\n`pull_type` can be either `GPIO.PULL_NONE`, `GPIO.PULL_UP`, or\n`GPIO.PULL_DOWN`.\n",
    "lang": "js"
  },
  {
    "name": "GPIO.setup_input(pin, pull_type)",
    "file": "[api_gpio.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_gpio.js)",
    "doc": "\n```javascript\nGPIO.setup_input(pin, pull_type)\n```\nSetup pin as input and configure pull type.\n`pull_type` can be either `GPIO.PULL_NONE`, `GPIO.PULL_UP`, or\n`GPIO.PULL_DOWN`.\n",
    "lang": "js"
  },
  {
    "name": "GPIO.setup_output(pin, level)",
    "file": "[api_gpio.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_gpio.js)",
    "doc": "\n```javascript\nGPIO.setup_output(pin, level)\n```\nSetup pin as output and set initial level, 0 or 1.\nAvoids spurious transitions: applies level first, then sets mode.\n",
    "lang": "js"
  },
  {
    "name": "GPIO.toggle(pin)",
    "file": "[api_gpio.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_gpio.js)",
    "doc": "\n```javascript\nGPIO.toggle(pin)\n```\nToggle the level of certain GPIO pin.\nReturn value: 0 or 1, indicating the resulting pin level.\n",
    "lang": "js"
  },
  {
    "name": "GPIO.write(pin, level)",
    "file": "[api_gpio.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_gpio.js)",
    "doc": "\n```javascript\nGPIO.write(pin, level)\n```\nSet GPIO pin level to either 0 or 1. Return value: none.\n",
    "lang": "js"
  },
  {
    "name": "GPIO.read(pin)",
    "file": "[api_gpio.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_gpio.js)",
    "doc": "\n```javascript\nGPIO.read(pin)\n```\nRead GPIO pin level. Return value: 0 or 1.\n",
    "lang": "js"
  },
  {
    "name": "GPIO.enable_int(pin)",
    "file": "[api_gpio.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_gpio.js)",
    "doc": "\n```javascript\nGPIO.enable_int(pin)\n```\nEnable interrupts on GPIO pin.\nThis function must be called AFTER the interrupt handler is installed.\nReturn value: 1 in case of success, 0 otherwise.\n",
    "lang": "js"
  },
  {
    "name": "GPIO.disable_int(pin)",
    "file": "[api_gpio.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_gpio.js)",
    "doc": "\n```javascript\nGPIO.disable_int(pin)\n```\nDisable interrupts on GPIO pin.\nReturn value: 1 in case of success, 0 otherwise.\n",
    "lang": "js"
  },
  {
    "name": "GPIO.blink(pin, on_ms, off_ms)",
    "file": "[api_gpio.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_gpio.js)",
    "doc": "\n```javascript\nGPIO.blink(pin, on_ms, off_ms)\n```\nA utility function that takes care of blinking an LED.\nThe pin must be configured as output first.\nOn (output \"1\") and off (\"0\") times are specified in milliseconds.\nSet to (0, 0) to disable.\nReturn value: 1 on success, 0 on failure.\n",
    "lang": "js"
  },
  {
    "name": "GPIO.set_int_handler(pin, mode, handler)",
    "file": "[api_gpio.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_gpio.js)",
    "doc": "\n```javascript\nGPIO.set_int_handler(pin, mode, handler)\n```\nInstall GPIO interrupt handler. `mode` could be one of: `GPIO.INT_NONE`,\n`GPIO.INT_EDGE_POS`, `GPIO.INT_EDGE_NEG`, `GPIO.INT_EDGE_ANY`,\n`GPIO.INT_LEVEL_HI`, `GPIO.INT_LEVEL_LO`.\nReturn value: 1 in case of success, 0 otherwise.\nExample:\n```javascript\nGPIO.set_mode(pin, GPIO.MODE_INPUT);\nGPIO.set_int_handler(pin, GPIO.INT_EDGE_NEG, function(pin) {\n   print('Pin', pin, 'got interrupt');\n}, null);\nGPIO.enable_int(pin);\n```\n",
    "lang": "js"
  },
  {
    "name": "GPIO.set_button_handler(pin, pull, intmode, period, handler)",
    "file": "[api_gpio.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_gpio.js)",
    "doc": "\n```javascript\nGPIO.set_button_handler(pin, pull, intmode, period, handler)\n```\nInstall\nGPIO button handler. `pull` is pull type, `intmode` is interrupt mode,\n`period` is debounce interval in milliseconds, handler is a function that\nreceives pin number.\nReturn value: 1 in case of success, 0 otherwise.\nExample:\n```javascript\nGPIO.set_button_handler(pin, GPIO.PULL_UP, GPIO.INT_EDGE_NEG, 200,\nfunction(x) {\n  print('Button press, pin: ', x);\n}, null);\n```\n",
    "lang": "js"
  },
  {
    "name": "_IRAM_STR_LIT",
    "file": "[mgos_iram.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_iram.h)",
    "doc": "\n```c\n#define _IRAM_STR_LIT(a) #a\n#define _IRAM_STR(a) _IRAM_STR_LIT(a)\n```\n> \n> Provides the IRAM macro that creates unique sections under .text\n> so that unused functions can be GC'd.\n>  \n",
    "lang": "c"
  },
  {
    "name": "MGOS_EVENT_BASE",
    "file": "[mgos_net.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_net.h)",
    "doc": "\n```c\n#define MGOS_EVENT_GRP_NET MGOS_EVENT_BASE('N', 'E', 'T')\n```\n> \n> Event group which should be given to `mgos_event_add_group_handler()`\n> in order to subscribe to network events.\n> \n> Example:\n> ```c\n> static void my_net_ev_handler(int ev, void *evd, void *arg) {\n>   if (ev == MGOS_NET_EV_IP_ACQUIRED) {\n>     LOG(LL_INFO, (\"Just got IP!\"));\n>     // Fetch something very useful from somewhere\n>   }\n>   (void) evd;\n>   (void) arg;\n> }\n> \n> // Somewhere else:\n> mgos_event_add_group_handler(MGOS_EVENT_GRP_NET, my_net_ev_handler, NULL);\n> ```\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_net_get_ip_info",
    "file": "[mgos_net.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_net.h)",
    "doc": "\n```c\nbool mgos_net_get_ip_info(enum mgos_net_if_type if_type, int if_instance,\n                          struct mgos_net_ip_info *ip_info);\n```\n> \n> Retrieve IP configuration of the provided interface type and instance\n> number, and fill provided `ip_info` with it. Returns `true` in case of\n> success, false otherwise.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_net_ip_to_str",
    "file": "[mgos_net.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_net.h)",
    "doc": "\n```c\nchar *mgos_net_ip_to_str(const struct sockaddr_in *sin, char *out);\n```\n> \n> Converts address to dotted-quad NUL-terminated string.\n> `out` must be at least 16 bytes long.\n> Returns the out pointer.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_net_str_to_ip",
    "file": "[mgos_net.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_net.h)",
    "doc": "\n```c\nbool mgos_net_str_to_ip(const char *ips, struct sockaddr_in *sin);\n```\n> \n> Parses dotted-quad NUL-terminated string into an IPv4 address.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_net_str_to_ip_n",
    "file": "[mgos_net.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_net.h)",
    "doc": "\n```c\nbool mgos_net_str_to_ip_n(const struct mg_str ips, struct sockaddr_in *sin);\n```\n> \n> Parses dotted-quad NUL-terminated string into an IPv4 address.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_get_nameserver",
    "file": "[mgos_net.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_net.h)",
    "doc": "\n```c\nchar *mgos_get_nameserver(void);\n```\n> \n> Returns nameserver address. The caller should `free()` it. Returns NULL\n> in case of no DNS.\n>  \n",
    "lang": "c"
  },
  {
    "name": "Net.ctos(conn, local, ip, port)",
    "file": "[api_net.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_net.js)",
    "doc": "\n```javascript\nNet.ctos(conn, local, ip, port)\n```\nConvert address of a connection `conn` to string. Set `local` to\n`true` to stringify local address, otherwise `false` to stringify remote.\nSet `ip` to `true` to stringify IP, `port` to stringify port. Example:\n```javascript\nprint('Connection from:', Net.ctos(conn, false, true, true));\n```\n",
    "lang": "js"
  },
  {
    "name": "Net.discard(conn, len)",
    "file": "[api_net.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_net.js)",
    "doc": "\n```javascript\nNet.discard(conn, len)\n```\nRemove initial `len` bytes of data from the connection's `conn`\nreceive buffer in order to discard that data and reclaim RAM to the system.\n",
    "lang": "js"
  },
  {
    "name": "Net.serve(options)",
    "file": "[api_net.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_net.js)",
    "doc": "\n```javascript\nNet.serve(options)\n```\nStart TCP or UDP server. `options` is an object:\n```javascript\n{\n   // Required. Port to listen on, 'tcp://PORT' or `udp://PORT`.\n   addr: 'tcp://1234',\n   // Optional. Called when connection is established.\n   onconnect: function(conn) {}, \n   // Optional. Called when new data is arrived.\n   ondata: function(conn, data) {},\n   // Optional. Called when protocol-specific event is triggered.\n   onevent: function(conn, data, ev, edata) {},\n   // Optional. Called when the connection is about to close.\n   onclose: function(conn) {},\n   // Optional. Called when on connection error.\n   onerror: function(conn) {},\n}\n```\nExample - a UDP echo server. Change `udp://` to `tcp://` to turn this\nexample into the TCP echo server:\n```javascript\nNet.serve({\n  addr: 'udp://1234',\n  ondata: function(conn, data) {\n    print('Received from:', Net.ctos(conn, false, true, true), ':', data);\n    Net.send(conn, data);            // Echo received data back\n    Net.discard(conn, data.length);  // Discard received data\n  },\n});\n```\n",
    "lang": "js"
  },
  {
    "name": "Net.connect(options)",
    "file": "[api_net.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_net.js)",
    "doc": "\n```javascript\nNet.connect(options)\n```\nConnect to a remote host. `options` is the same as for the `Net.serve`.\nThe addr format is `[PROTO://]HOST:PORT`. `PROTO` could be `tcp` or\n`udp`. `HOST` could be an IP address or a host name. If `HOST` is a name,\nit will be resolved asynchronously.\n\nExamples of valid addresses: `google.com:80`, `udp://1.2.3.4:53`,\n`10.0.0.1:443`, `[::1]:80`.\n",
    "lang": "js"
  },
  {
    "name": "Net.close(conn)",
    "file": "[api_net.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_net.js)",
    "doc": "\n```javascript\nNet.close(conn)\n```\nSend all pending data to the remote peer,\nand disconnect when all data is sent.\nReturn value: none.\n",
    "lang": "js"
  },
  {
    "name": "Net.send(conn, data)",
    "file": "[api_net.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_net.js)",
    "doc": "\n```javascript\nNet.send(conn, data)\n```\nSend data to the remote peer. `data` is an mJS string.\nReturn value: none.\n",
    "lang": "js"
  },
  {
    "name": "Net.EVENT_GRP",
    "file": "[api_net.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_net.js)",
    "doc": "\n```javascript\nNet.EVENT_GRP\n```\nNet events group, to be used with `Event.addGroupHandler()`. Possible\nevents are:\n- `Net.STATUS_DISCONNECTED`\n- `Net.STATUS_CONNECTING`\n- `Net.STATUS_CONNECTED`\n- `Net.STATUS_GOT_IP`\n",
    "lang": "js"
  },
  {
    "name": "mgos_sys_config_save",
    "file": "[mgos_sys_config.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_sys_config.h)",
    "doc": "\n```c\nbool mgos_sys_config_save(const struct mgos_config *cfg, bool try_once,\n                          char **msg);\n```\n> \n> Save config. Performs diff against defaults and only saves diffs.\n> Reboot is required to reload the config.\n> If try_once is set, the config will only take effect for one boot.\n> \n> If return value is false, a message may be provided in *msg.\n> If non-NULL, it must be free()d.\n> It is safe to pass a NULL `msg`\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_sys_config_save_level",
    "file": "[mgos_sys_config.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_sys_config.h)",
    "doc": "\n```c\nbool mgos_sys_config_save_level(const struct mgos_config *cfg,\n                                enum mgos_config_level level, bool try_once,\n                                char **msg);\n```\n>  Saves given coonfig at the specified level. Performs diff against level-1. \n",
    "lang": "c"
  },
  {
    "name": "mgos_sys_config_load_level",
    "file": "[mgos_sys_config.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_sys_config.h)",
    "doc": "\n```c\nbool mgos_sys_config_load_level(struct mgos_config *cfg,\n                                enum mgos_config_level level);\n```\n>  Loads config up to and including level. \n",
    "lang": "c"
  },
  {
    "name": "save_cfg",
    "file": "[mgos_sys_config.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_sys_config.h)",
    "doc": "\n```c\nbool save_cfg(const struct mgos_config *cfg, char **msg);\n```\n>  Deprecated API, equivalent to mgos_sys_config_save(cfg, false, msg). \n",
    "lang": "c"
  },
  {
    "name": "load_config_defaults",
    "file": "[mgos_sys_config.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_sys_config.h)",
    "doc": "\n```c\nbool load_config_defaults(struct mgos_config *cfg);\n```\n>  Loads configs up to MGOS_CONFIG_LEVEL_USER - 1. Deprecated. \n",
    "lang": "c"
  },
  {
    "name": "mgos_config_reset",
    "file": "[mgos_sys_config.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_sys_config.h)",
    "doc": "\n```c\nvoid mgos_config_reset(int level);\n```\n> \n> Reset config down to and including |level|.\n> 0 - defaults, 1-8 - vendor levels, 9 - user.\n> mgos_config_reset(MGOS_CONFIG_LEVEL_USER) will wipe user settings.\n>  \n",
    "lang": "c"
  },
  {
    "name": "(*mgos_config_validator_fn)",
    "file": "[mgos_sys_config.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_sys_config.h)",
    "doc": "\n```c\ntypedef bool (*mgos_config_validator_fn)(const struct mgos_config *cfg,\n                                         char **msg);\nvoid mgos_sys_config_register_validator(mgos_config_validator_fn fn);\n```\n> \n> Register a config validator.\n> Validators will be invoked before saving config and if any of them\n> returns false, config will not be saved.\n> An error message may be *msg may be set to error message.\n> Note: if non-NULL, *msg will be freed. Remember to use strdup and asprintf.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_config_validate",
    "file": "[mgos_sys_config.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_sys_config.h)",
    "doc": "\n```c\nbool mgos_config_validate(const struct mgos_config *cfg, char **msg);\n```\n>  Run validators on the specified config. \n",
    "lang": "c"
  },
  {
    "name": "mgos_expand_mac_address_placeholders",
    "file": "[mgos_sys_config.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_sys_config.h)",
    "doc": "\n```c\nvoid mgos_expand_mac_address_placeholders(char *str);\n```\n>  Expands question marks in \"str\" with digits from the MAC address. \n",
    "lang": "c"
  },
  {
    "name": "mgos_config_apply",
    "file": "[mgos_sys_config.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_sys_config.h)",
    "doc": "\n```c\nbool mgos_config_apply(const char *sys_config_subset_json, bool save);\n```\n>  Apply a subset of system configuration. Return true on success. \n",
    "lang": "c"
  },
  {
    "name": "mgos_config_apply_s",
    "file": "[mgos_sys_config.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_sys_config.h)",
    "doc": "\n```c\nbool mgos_config_apply_s(const struct mg_str, bool save);\n```\n>  Same as mgos_config_apply but uses mg_str \n",
    "lang": "c"
  },
  {
    "name": "mgos_sys_config_parse_sub",
    "file": "[mgos_sys_config.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_sys_config.h)",
    "doc": "\n```c\nbool mgos_sys_config_parse_sub(const struct mg_str json, const char *section,\n                               void *cfg);\n```\n> \n> Parse a subsection of sys config, e.g. just \"spi\".\n> cfg must point to the subsection's struct.\n> Example:\n> ```\n>   struct mgos_config_spi cfg;\n>   const struct mg_str json_cfg = MG_MK_STR(\"{\\\"unit_no\\\": 1}\");\n>   memset(&cfg, 0, sizeof(cfg));\n>   mgos_sys_config_parse_sub(json_cfg, \"spi\", cfg);\n> ```\n>  \n",
    "lang": "c"
  },
  {
    "name": "Cfg.get(path)",
    "file": "[api_config.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_config.js)",
    "doc": "\n```javascript\nCfg.get(path)\n```\nGet the config value by the configuration variable. Currently, only\nsimple types are returned: strings, ints, booleans, doubles. Objects\nare not yet supported.\n\nExamples:\n```javascript\nload('api_config.js');\nCfg.get('device.id');        // returns a string\nCfg.get('debug.level');      // returns an integer\nCfg.get('wifi.sta.enable');  // returns a boolean\n```\n",
    "lang": "js"
  },
  {
    "name": "Cfg.set(obj, opt_save)",
    "file": "[api_config.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_config.js)",
    "doc": "\n```javascript\nCfg.set(obj, opt_save)\n```\nSet the configuration. `obj` must be a subset of the whole configuation\ntree. `save` is boolean flag that indicating whether the change should\nbe saved - it could be omitted, in which case it defaults to `true`.\nExamples:\n```javascript\nload('api_config.js');\nCfg.set({wifi: {ap: {enable: false}}});  // Disable WiFi AP mode\nCfg.set({debug: {level: 3}});            // Set debug level to 3\n```\n",
    "lang": "js"
  },
  {
    "name": "mgos_get_heap_size",
    "file": "[mgos_system.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_system.h)",
    "doc": "\n```c\nsize_t mgos_get_heap_size(void);\n```\n>  Get system memory size. \n",
    "lang": "c"
  },
  {
    "name": "mgos_get_free_heap_size",
    "file": "[mgos_system.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_system.h)",
    "doc": "\n```c\nsize_t mgos_get_free_heap_size(void);\n```\n>  Get system free memory. \n",
    "lang": "c"
  },
  {
    "name": "mgos_get_min_free_heap_size",
    "file": "[mgos_system.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_system.h)",
    "doc": "\n```c\nsize_t mgos_get_min_free_heap_size(void);\n```\n>  Get minimal watermark of the system free memory. \n",
    "lang": "c"
  },
  {
    "name": "mgos_get_fs_memory_usage",
    "file": "[mgos_system.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_system.h)",
    "doc": "\n```c\nsize_t mgos_get_fs_memory_usage(void);\n```\n>  Get filesystem memory usage \n",
    "lang": "c"
  },
  {
    "name": "mgos_get_fs_size",
    "file": "[mgos_system.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_system.h)",
    "doc": "\n```c\nsize_t mgos_get_fs_size(void);\n```\n> \n> Get filesystem size.\n> Deprecated, please use mgos_vfs_get_space_total(\"/\") instead.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_get_free_fs_size",
    "file": "[mgos_system.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_system.h)",
    "doc": "\n```c\nsize_t mgos_get_free_fs_size(void);\n```\n> \n> Get filesystem free space.\n> Deprecated, please use mgos_vfs_get_space_free(\"/\") instead.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_fs_gc",
    "file": "[mgos_system.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_system.h)",
    "doc": "\n```c\nvoid mgos_fs_gc(void);\n```\n>  Garbage-collect filesystem \n",
    "lang": "c"
  },
  {
    "name": "mgos_wdt_feed",
    "file": "[mgos_system.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_system.h)",
    "doc": "\n```c\nvoid mgos_wdt_feed(void);\n```\n>  Feed watchdog \n",
    "lang": "c"
  },
  {
    "name": "mgos_wdt_set_timeout",
    "file": "[mgos_system.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_system.h)",
    "doc": "\n```c\nvoid mgos_wdt_set_timeout(int secs);\n```\n>  Set watchdog timeout\n",
    "lang": "c"
  },
  {
    "name": "mgos_wdt_enable",
    "file": "[mgos_system.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_system.h)",
    "doc": "\n```c\nvoid mgos_wdt_enable(void);\n```\n>  Enable watchdog \n",
    "lang": "c"
  },
  {
    "name": "mgos_wdt_disable",
    "file": "[mgos_system.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_system.h)",
    "doc": "\n```c\nvoid mgos_wdt_disable(void);\n```\n>  Disable watchdog \n",
    "lang": "c"
  },
  {
    "name": "mgos_system_restart",
    "file": "[mgos_system.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_system.h)",
    "doc": "\n```c\nvoid mgos_system_restart(void) __attribute__((noreturn));\n```\n>  Restart system \n",
    "lang": "c"
  },
  {
    "name": "mgos_msleep",
    "file": "[mgos_system.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_system.h)",
    "doc": "\n```c\nvoid mgos_msleep(uint32_t msecs);\n```\n>  Delay given number of milliseconds \n",
    "lang": "c"
  },
  {
    "name": "mgos_usleep",
    "file": "[mgos_system.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_system.h)",
    "doc": "\n```c\nvoid mgos_usleep(uint32_t usecs);\n```\n>  Delay given number of microseconds \n",
    "lang": "c"
  },
  {
    "name": "mgos_ints_disable",
    "file": "[mgos_system.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_system.h)",
    "doc": "\n```c\nvoid mgos_ints_disable(void);\n```\n>  Disable interrupts \n",
    "lang": "c"
  },
  {
    "name": "mgos_ints_enable",
    "file": "[mgos_system.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_system.h)",
    "doc": "\n```c\nvoid mgos_ints_enable(void);\n```\n>  Enable interrupts \n",
    "lang": "c"
  },
  {
    "name": "(*mgos_cb_t)",
    "file": "[mgos_system.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_system.h)",
    "doc": "\n```c\ntypedef void (*mgos_cb_t)(void *arg);\n```\n>  Callback for `mgos_invoke_cb()` \n",
    "lang": "c"
  },
  {
    "name": "mgos_invoke_cb",
    "file": "[mgos_system.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_system.h)",
    "doc": "\n```c\nbool mgos_invoke_cb(mgos_cb_t cb, void *arg, bool from_isr);\n```\n> \n> Invoke a callback in the main MGOS event loop.\n> Returns true if the callback has been scheduled for execution.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_get_cpu_freq",
    "file": "[mgos_system.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_system.h)",
    "doc": "\n```c\nuint32_t mgos_get_cpu_freq(void);\n```\n>  Get the CPU frequency in Hz \n",
    "lang": "c"
  },
  {
    "name": "mgos_rlock_create",
    "file": "[mgos_system.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_system.h)",
    "doc": "\n```c\nstruct mgos_rlock_type *mgos_rlock_create(void);\n```\n>  Create a recursive lock. \n",
    "lang": "c"
  },
  {
    "name": "mgos_rlock",
    "file": "[mgos_system.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_system.h)",
    "doc": "\n```c\nvoid mgos_rlock(struct mgos_rlock_type *l);\n```\n>  Acquire a recursive lock. \n",
    "lang": "c"
  },
  {
    "name": "mgos_runlock",
    "file": "[mgos_system.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_system.h)",
    "doc": "\n```c\nvoid mgos_runlock(struct mgos_rlock_type *l);\n```\n>  Release a recursive lock. \n",
    "lang": "c"
  },
  {
    "name": "mgos_rlock_destroy",
    "file": "[mgos_system.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_system.h)",
    "doc": "\n```c\nvoid mgos_rlock_destroy(struct mgos_rlock_type *l);\n```\n>  Destroy a recursive lock. \n",
    "lang": "c"
  },
  {
    "name": "Sys._sbuf(len)",
    "file": "[api_sys.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_sys.js)",
    "doc": "\n```javascript\nSys._sbuf(len)\n```\nHelper function to allocate string of at least given length. Note that\nthe resulting string is usually bigger than this, and it is always\nlonger than 5 bytes; that's to guarantee that the string data is stored in\na common buffer and not inlined into mjs_val_t, thus the buffer can be\nused as an \"output\" buffer: a string can be passed to some function which\nwill alter the contents, and these changes will be visible to the caller.\n",
    "lang": "js"
  },
  {
    "name": "Sys.calloc(nmemb, size)",
    "file": "[api_sys.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_sys.js)",
    "doc": "\n```javascript\nSys.calloc(nmemb, size)\n```\nAllocate a memory region.\nNote: currently memory allocated this way must be explicitly released with\n`free()`.\n",
    "lang": "js"
  },
  {
    "name": "Sys.total_ram()",
    "file": "[api_sys.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_sys.js)",
    "doc": "\n```javascript\nSys.total_ram()\n```\nReturn total available RAM in bytes.\n",
    "lang": "js"
  },
  {
    "name": "Sys.free_ram()",
    "file": "[api_sys.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_sys.js)",
    "doc": "\n```javascript\nSys.free_ram()\n```\nReturn free available RAM in bytes.\n",
    "lang": "js"
  },
  {
    "name": "Sys.reboot(ms)",
    "file": "[api_sys.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_sys.js)",
    "doc": "\n```javascript\nSys.reboot(ms)\n```\nReboot the system after `ms` milliseconds. Return value: none.\n",
    "lang": "js"
  },
  {
    "name": "Sys.uptime()",
    "file": "[api_sys.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_sys.js)",
    "doc": "\n```javascript\nSys.uptime()\n```\nReturn number of seconds since last reboot.\n",
    "lang": "js"
  },
  {
    "name": "Sys.usleep(microseconds)",
    "file": "[api_sys.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_sys.js)",
    "doc": "\n```javascript\nSys.usleep(microseconds)\n```\nSleep given number of microseconds.\nReturn value: none.\n",
    "lang": "js"
  },
  {
    "name": "Sys.wdt_feed()",
    "file": "[api_sys.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_sys.js)",
    "doc": "\n```javascript\nSys.wdt_feed()\n```\nFeed the watchdog timer.\nReturn value: none.\n",
    "lang": "js"
  },
  {
    "name": "mgos_uptime",
    "file": "[mgos_time.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_time.h)",
    "doc": "\n```c\ndouble mgos_uptime(void);\n```\n>  Get number of seconds since last reboot \n",
    "lang": "c"
  },
  {
    "name": "mgos_uptime_micros",
    "file": "[mgos_time.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_time.h)",
    "doc": "\n```c\nint64_t mgos_uptime_micros(void);\n```\n>  Get number of microseconds since last reboot \n",
    "lang": "c"
  },
  {
    "name": "mgos_strftime",
    "file": "[mgos_time.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_time.h)",
    "doc": "\n```c\nint mgos_strftime(char *s, int size, char *fmt, int time);\n```\n> \n> Format `time` according to a `strftime()`-conformant format.\n> Write the result into the `s,size` buffer. Return resulting string length.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_settimeofday",
    "file": "[mgos_time.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_time.h)",
    "doc": "\n```c\nint mgos_settimeofday(double time, struct timezone *tz);\n```\n> \n> Like standard `settimeofday()`, but uses `double` seconds value instead of\n> `struct timeval *tv`. If time was changed successfully, emits an event\n> `MGOS_EVENT_TIME_CHANGED`.\n>  \n",
    "lang": "c"
  },
  {
    "name": "(*timer_callback)",
    "file": "[mgos_timers.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_timers.h)",
    "doc": "\n```c\ntypedef void (*timer_callback)(void *param);\n```\n>  Timer callback \n",
    "lang": "c"
  },
  {
    "name": "mgos_set_timer",
    "file": "[mgos_timers.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_timers.h)",
    "doc": "\n```c\nmgos_timer_id mgos_set_timer(int msecs, int flags, timer_callback cb,\n                             void *cb_arg);\n```\n> \n> Setup a timer with `msecs` timeout and `cb` as a callback.\n> \n> `flags` is a bitmask, currently there's only one flag available:\n> `MGOS_TIMER_REPEAT` (see above). `arg` is a parameter to pass to `cb`.\n> Return numeric timer ID.\n> \n> Note that this is a software timer, with fairly low accuracy and high jitter.\n> However, number of software timers is not limited.\n> If you need intervals < 10ms, use mgos_set_hw_timer.\n> \n> Example:\n> ```c\n> static void my_timer_cb(void *arg) {\n>   bool val = mgos_gpio_toggle(mgos_sys_config_get_pins_led());\n>   LOG(LL_INFO, (\"uptime: %.2lf\", mgos_uptime()));\n>   (void) arg;\n> }\n> \n> enum mgos_app_init_result mgos_app_init(void) {\n>   mgos_set_timer(1000, MGOS_TIMER_REPEAT, my_timer_cb, NULL);\n>   return MGOS_APP_INIT_SUCCESS;\n> }\n> ```\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_set_hw_timer",
    "file": "[mgos_timers.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_timers.h)",
    "doc": "\n```c\nmgos_timer_id mgos_set_hw_timer(int usecs, int flags, timer_callback cb,\n                                void *cb_arg);\n```\n> \n> Setup a hardware timer with `usecs` timeout and `cb` as a callback.\n> \n> This is similar to mgos_set_timer, but can be used for shorter intervals\n> (note that time unit is microseconds).\n> \n> Number of hardware timers is limited (ESP8266: 1, ESP32: 4, CC32xx: 4).\n> \n> Callback is executed in ISR context, with all the implications of that.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_clear_timer",
    "file": "[mgos_timers.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_timers.h)",
    "doc": "\n```c\nvoid mgos_clear_timer(mgos_timer_id id);\n```\n> \n> Disable timer with a given timer ID.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_uptime",
    "file": "[mgos_timers.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_timers.h)",
    "doc": "\n```c\ndouble mgos_uptime(void);\n```\n>  Get number of seconds since last reboot \n",
    "lang": "c"
  },
  {
    "name": "mgos_strftime",
    "file": "[mgos_timers.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_timers.h)",
    "doc": "\n```c\nint mgos_strftime(char *s, int size, char *fmt, int time);\n```\n> \n> Format `time` according to a `strftime()`-conformant format.\n> Write the result into the `s,size` buffer. Return resulting string length.\n>  \n",
    "lang": "c"
  },
  {
    "name": "Timer.set(milliseconds, flags, handler, userdata)",
    "file": "[api_timer.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_timer.js)",
    "doc": "\n```javascript\nTimer.set(milliseconds, flags, handler, userdata)\n```\nSetup timer with `milliseconds` timeout and `handler` as a callback.\n`flags` can be either 0 or `Timer.REPEAT`. In the latter case, the call\nwill be repeated indefinitely (but can be cancelled with `Timer.del()`),\notherwise it's a one-off.\n\nReturn value: numeric timer ID.\n\nExample:\n```javascript\n// Call every second\nTimer.set(1000, Timer.REPEAT, function() {\n  let value = GPIO.toggle(2);\n  print(value ? 'Tick' : 'Tock');\n}, null);\n```\n",
    "lang": "js"
  },
  {
    "name": "Timer.now()",
    "file": "[api_timer.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_timer.js)",
    "doc": "\n```javascript\nTimer.now()\n```\nReturn current time as double value, UNIX epoch (seconds since 1970).\n",
    "lang": "js"
  },
  {
    "name": "Timer.del(id)",
    "file": "[api_timer.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_timer.js)",
    "doc": "\n```javascript\nTimer.del(id)\n```\nCancel previously installed timer.\n",
    "lang": "js"
  },
  {
    "name": "Timer.fmt(fmt, time)",
    "file": "[api_timer.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_timer.js)",
    "doc": "\n```javascript\nTimer.fmt(fmt, time)\n```\nFormats the time 'time' according to the strftime-like format\nspecification 'fmt'. The strftime reference can be found e.g.\n[here](http://www.cplusplus.com/reference/ctime/strftime/).\nExample:\n```javascript\nlet now = Timer.now();\nlet s = Timer.fmt(\"Now it's %I:%M%p.\", now);\nprint(s); // Example output: \"Now it's 12:01AM.\"\n```\n",
    "lang": "js"
  },
  {
    "name": "mgos_uart_configure",
    "file": "[mgos_uart.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_uart.h)",
    "doc": "\n```c\nbool mgos_uart_configure(int uart_no, const struct mgos_uart_config *cfg);\n```\n> \n> Apply given UART configuration.\n> \n> Example:\n> ```c\n> int uart_no = 0;\n> \n> struct mgos_uart_config ucfg;\n> mgos_uart_config_set_defaults(uart_no, &ucfg);\n> \n> ucfg.baud_rate = 115200;\n> ucfg.rx_buf_size = 1500;\n> ucfg.tx_buf_size = 1500;\n> \n> if (!mgos_uart_configure(uart_no, &ucfg)) {\n>   LOG(LL_ERROR, (\"Failed to configure UART%d\", uart_no));\n> }\n> ```\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_uart_config_set_defaults",
    "file": "[mgos_uart.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_uart.h)",
    "doc": "\n```c\nvoid mgos_uart_config_set_defaults(int uart_no, struct mgos_uart_config *cfg);\n```\n> \n> Fill provided `cfg` structure with the default values. See example above.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_uart_config_get",
    "file": "[mgos_uart.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_uart.h)",
    "doc": "\n```c\nbool mgos_uart_config_get(int uart_no, struct mgos_uart_config *cfg);\n```\n> \n> Fill provided `cfg` structure with the current UART config.\n> Returns false if the specified UART has not bee configured yet.\n>  \n",
    "lang": "c"
  },
  {
    "name": "(*mgos_uart_dispatcher_t)",
    "file": "[mgos_uart.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_uart.h)",
    "doc": "\n```c\ntypedef void (*mgos_uart_dispatcher_t)(int uart_no, void *arg);\n```\n>  UART dispatcher signature, see `mgos_uart_set_dispatcher()` \n",
    "lang": "c"
  },
  {
    "name": "mgos_uart_set_dispatcher",
    "file": "[mgos_uart.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_uart.h)",
    "doc": "\n```c\nvoid mgos_uart_set_dispatcher(int uart_no, mgos_uart_dispatcher_t cb,\n                              void *arg);\n```\n> \n> Set UART dispatcher: a callback which gets called when there is data in the\n> input buffer or space available in the output buffer.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_uart_write",
    "file": "[mgos_uart.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_uart.h)",
    "doc": "\n```c\nsize_t mgos_uart_write(int uart_no, const void *buf, size_t len);\n```\n> \n> Write data to the UART.\n> Note: if there is enough space in the output buffer, the call will return\n> immediately, otherwise it will wait for buffer to drain.\n> If you want the call to not block, check mgos_uart_write_avail() first.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_uart_write_avail",
    "file": "[mgos_uart.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_uart.h)",
    "doc": "\n```c\nsize_t mgos_uart_write_avail(int uart_no);\n```\n>  Returns amount of space availabe in the output buffer. \n",
    "lang": "c"
  },
  {
    "name": "mgos_uart_printf",
    "file": "[mgos_uart.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_uart.h)",
    "doc": "\n```c\nint mgos_uart_printf(int uart_no, const char *fmt, ...);\n```\n> \n> Write data to UART, printf style.\n> Note: currently this requires that data is fully rendered in memory before\n> sending. There is no fixed limit as heap allocation is used, but be careful\n> when printing longer strings.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_uart_read",
    "file": "[mgos_uart.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_uart.h)",
    "doc": "\n```c\nsize_t mgos_uart_read(int uart_no, void *buf, size_t len);\n```\n> \n> Read data from UART input buffer.\n> Note: unlike write, read will not block if there are not enough bytes in the\n> input buffer.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_uart_read_mbuf",
    "file": "[mgos_uart.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_uart.h)",
    "doc": "\n```c\nsize_t mgos_uart_read_mbuf(int uart_no, struct mbuf *mb, size_t len);\n```\n>  Like `mgos_uart_read`, but reads into an mbuf. \n",
    "lang": "c"
  },
  {
    "name": "mgos_uart_read_avail",
    "file": "[mgos_uart.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_uart.h)",
    "doc": "\n```c\nsize_t mgos_uart_read_avail(int uart_no);\n```\n>  Returns the number of bytes available for reading. \n",
    "lang": "c"
  },
  {
    "name": "mgos_uart_set_rx_enabled",
    "file": "[mgos_uart.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_uart.h)",
    "doc": "\n```c\nvoid mgos_uart_set_rx_enabled(int uart_no, bool enabled);\n```\n>  Controls whether UART receiver is enabled. \n",
    "lang": "c"
  },
  {
    "name": "mgos_uart_is_rx_enabled",
    "file": "[mgos_uart.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_uart.h)",
    "doc": "\n```c\nbool mgos_uart_is_rx_enabled(int uart_no);\n```\n>  Returns whether UART receiver is enabled. \n",
    "lang": "c"
  },
  {
    "name": "mgos_uart_flush",
    "file": "[mgos_uart.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_uart.h)",
    "doc": "\n```c\nvoid mgos_uart_flush(int uart_no);\n```\n>  Flush the UART output buffer - waits for data to be sent. \n",
    "lang": "c"
  },
  {
    "name": "mgos_uart_schedule_dispatcher",
    "file": "[mgos_uart.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_uart.h)",
    "doc": "\n```c\nvoid mgos_uart_schedule_dispatcher(int uart_no, bool from_isr);\n```\n>  Schedule a call to dispatcher on the next `mongoose_poll` \n",
    "lang": "c"
  },
  {
    "name": "mgos_uart_get_stats",
    "file": "[mgos_uart.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_uart.h)",
    "doc": "\n```c\nconst struct mgos_uart_stats *mgos_uart_get_stats(int uart_no);\n```\n>  Get UART statistics \n",
    "lang": "c"
  },
  {
    "name": "UART.setConfig(uartNo, param)",
    "file": "[api_uart.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_uart.js)",
    "doc": "\n```javascript\nUART.setConfig(uartNo, param)\n```\nSet UART config. `param` is an\nobject with the following optional fields:\n\n- `baudRate`: baud rate, integer, default: 115200;\n- `numDataBits`: Number of data bits, default: 8;\n- `parity`: Parity: 0 - none, 1 - even, 2 - odd; default: none;\n- `numStopBits`: Number of stop bits: 1 - 1 bit, 2 - 2 bits, 3 - 1.5; default: 1;\n- `rxBufSize`: size of the Rx buffer, integer, default: 256;\n- `rxFlowControl`: whether Rx flow control (RTS pin) is enabled, boolean,\n   default: false;\n- `rxLingerMicros`: how many microseconds to linger after Rx fifo\n  is empty, in case more data arrives. Integer, default: 15;\n- `txBufSize`: size of the Tx buffer, integer, default: 256;\n- `txFlowControl`: whether Tx flow control (CTS pin) is enabled, boolean,\n  default: false;\n\nOther than that, there are architecture-dependent settings, grouped in\nthe objects named with the architecture name: \"esp32\", \"esp8266\", etc.\n\nSettings for esp32:\n\n```\n  esp32: {\n     /*\n      * GPIO pin numbers, default values depend on UART.\n      *\n      * UART 0: Rx: 3, Tx: 1, CTS: 19, RTS: 22\n      * UART 1: Rx: 13, Tx: 14, CTS: 15, RTS: 16\n      * UART 2: Rx: 17, Tx: 25, CTS: 26, RTS: 27\n      */\n     gpio: {\n       rx: number,\n       tx: number,\n       cts: number,\n       rts: number,\n     },\n\n     /* Hardware FIFO tweaks */\n     fifo: {\n       /*\n        * A number of bytes in the hardware Rx fifo, should be between 1 and 127.\n        * How full hardware Rx fifo should be before \"rx fifo full\" interrupt is\n        * fired.\n        */\n       rxFullThresh: number,\n\n       /*\n        * A number of bytes in the hardware Rx fifo, should be more than\n        * rx_fifo_full_thresh.\n        *\n        * How full hardware Rx fifo should be before CTS is deasserted, telling\n        * the other side to stop sending data.\n        */\n       rxFcThresh: number,\n\n       /*\n        * Time in uart bit intervals when \"rx fifo full\" interrupt fires even if\n        * it's not full enough\n        */\n       rxAlarm: number,\n\n       /*\n        * A number of bytes in the hardware Tx fifo, should be between 1 and 127.\n        * When the number of bytes in Tx buffer becomes less than\n        * tx_fifo_empty_thresh, \"tx fifo empty\" interrupt fires.\n        */\n       txEmptyThresh: number,\n     },\n   }\n```\n",
    "lang": "js"
  },
  {
    "name": "UART.setDispatcher(uartNo, callback, userdata)",
    "file": "[api_uart.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_uart.js)",
    "doc": "\n```javascript\nUART.setDispatcher(uartNo, callback, userdata)\n```\nSet UART dispatcher\ncallback which gets invoked when there is a new data in the input buffer\nor when the space becomes available on the output buffer.\n\nCallback receives the following arguments: `(uartNo, userdata)`.\n",
    "lang": "js"
  },
  {
    "name": "UART.write(uartNo, data)",
    "file": "[api_uart.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_uart.js)",
    "doc": "\n```javascript\nUART.write(uartNo, data)\n```\nWrite data to the buffer. Returns number of bytes written.\n\nExample usage: `UART.write(1, \"foobar\")`, in this case, 6 bytes will be written.\n",
    "lang": "js"
  },
  {
    "name": "UART.writeAvail(uartNo)",
    "file": "[api_uart.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_uart.js)",
    "doc": "\n```javascript\nUART.writeAvail(uartNo)\n```\nReturn amount of space available in the output buffer.\n",
    "lang": "js"
  },
  {
    "name": "UART.read(uartNo)",
    "file": "[api_uart.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_uart.js)",
    "doc": "\n```javascript\nUART.read(uartNo)\n```\nIt never blocks, and returns a string containing\nread data (which will be empty if there's no data available).\n",
    "lang": "js"
  },
  {
    "name": "UART.readAvail(uartNo)",
    "file": "[api_uart.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_uart.js)",
    "doc": "\n```javascript\nUART.readAvail(uartNo)\n```\nReturn amount of data available in the input buffer.\n",
    "lang": "js"
  },
  {
    "name": "UART.setRxEnabled(uartNo)",
    "file": "[api_uart.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_uart.js)",
    "doc": "\n```javascript\nUART.setRxEnabled(uartNo)\n```\nSet whether Rx is enabled.\n",
    "lang": "js"
  },
  {
    "name": "UART.isRxEnabled(uartNo)",
    "file": "[api_uart.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_uart.js)",
    "doc": "\n```javascript\nUART.isRxEnabled(uartNo)\n```\nReturns whether Rx is enabled.\n",
    "lang": "js"
  },
  {
    "name": "UART.flush(uartNo)",
    "file": "[api_uart.js](https://github.com/mongoose-os-libs/mjs/blob/master/fs/api_uart.js)",
    "doc": "\n```javascript\nUART.flush(uartNo)\n```\nFlush the UART output buffer, wait for the data to be sent.\n",
    "lang": "js"
  },
  {
    "name": "mgos_system_restart_after",
    "file": "[mgos_utils.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_utils.h)",
    "doc": "\n```c\nvoid mgos_system_restart_after(int delay_ms);\n```\n>  Restart system after the specified number of milliseconds \n",
    "lang": "c"
  },
  {
    "name": "mgos_rand_range",
    "file": "[mgos_utils.h](https://github.com/cesanta/mongoose-os/blob/master/include/mgos_utils.h)",
    "doc": "\n```c\nfloat mgos_rand_range(float from, float to);\n```\n>  Return random number in a given range. \n",
    "lang": "c"
  },
  {
    "name": "(*json_walk_callback_t)",
    "file": "[frozen.h](https://github.com/cesanta/frozen/blob/master/frozen.h)",
    "doc": "\n```c\ntypedef void (*json_walk_callback_t)(void *callback_data, const char *name,\n                                     size_t name_len, const char *path,\n                                     const struct json_token *token);\n```\n> \n> Callback-based SAX-like API.\n> \n> Property name and length is given only if it's available: i.e. if current\n> event is an object's property. In other cases, `name` is `NULL`. For\n> example, name is never given:\n>   - For the first value in the JSON string;\n>   - For events JSON_TYPE_OBJECT_END and JSON_TYPE_ARRAY_END\n> \n> E.g. for the input `{ \"foo\": 123, \"bar\": [ 1, 2, { \"baz\": true } ] }`,\n> the sequence of callback invocations will be as follows:\n> \n> - type: JSON_TYPE_OBJECT_START, name: NULL, path: \"\", value: NULL\n> - type: JSON_TYPE_NUMBER, name: \"foo\", path: \".foo\", value: \"123\"\n> - type: JSON_TYPE_ARRAY_START,  name: \"bar\", path: \".bar\", value: NULL\n> - type: JSON_TYPE_NUMBER, name: \"0\", path: \".bar[0]\", value: \"1\"\n> - type: JSON_TYPE_NUMBER, name: \"1\", path: \".bar[1]\", value: \"2\"\n> - type: JSON_TYPE_OBJECT_START, name: \"2\", path: \".bar[2]\", value: NULL\n> - type: JSON_TYPE_TRUE, name: \"baz\", path: \".bar[2].baz\", value: \"true\"\n> - type: JSON_TYPE_OBJECT_END, name: NULL, path: \".bar[2]\", value: \"{ \\\"baz\\\":\n> true }\"\n> - type: JSON_TYPE_ARRAY_END, name: NULL, path: \".bar\", value: \"[ 1, 2, {\n> \\\"baz\\\": true } ]\"\n> - type: JSON_TYPE_OBJECT_END, name: NULL, path: \"\", value: \"{ \\\"foo\\\": 123,\n> \\\"bar\\\": [ 1, 2, { \\\"baz\\\": true } ] }\"\n>  \n",
    "lang": "c"
  },
  {
    "name": "json_walk",
    "file": "[frozen.h](https://github.com/cesanta/frozen/blob/master/frozen.h)",
    "doc": "\n```c\nint json_walk(const char *json_string, int json_string_length,\n              json_walk_callback_t callback, void *callback_data);\n```\n> \n> Parse `json_string`, invoking `callback` in a way similar to SAX parsers;\n> see `json_walk_callback_t`.\n> Return number of processed bytes, or a negative error code.\n>  \n",
    "lang": "c"
  },
  {
    "name": "json_printf",
    "file": "[frozen.h](https://github.com/cesanta/frozen/blob/master/frozen.h)",
    "doc": "\n```c\nint json_printf(struct json_out *, const char *fmt, ...);\nint json_vprintf(struct json_out *, const char *fmt, va_list ap);\n```\n> \n> Generate formatted output into a given sting buffer.\n> This is a superset of printf() function, with extra format specifiers:\n>  - `%B` print json boolean, `true` or `false`. Accepts an `int`.\n>  - `%Q` print quoted escaped string or `null`. Accepts a `const char *`.\n>  - `%.*Q` same as `%Q`, but with length. Accepts `int`, `const char *`\n>  - `%V` print quoted base64-encoded string. Accepts a `const char *`, `int`.\n>  - `%H` print quoted hex-encoded string. Accepts a `int`, `const char *`.\n>  - `%M` invokes a json_printf_callback_t function. That callback function\n>  can consume more parameters.\n> \n> Return number of bytes printed. If the return value is bigger than the\n> supplied buffer, that is an indicator of overflow. In the overflow case,\n> overflown bytes are not printed.\n>  \n",
    "lang": "c"
  },
  {
    "name": "json_fprintf",
    "file": "[frozen.h](https://github.com/cesanta/frozen/blob/master/frozen.h)",
    "doc": "\n```c\nint json_fprintf(const char *file_name, const char *fmt, ...);\nint json_vfprintf(const char *file_name, const char *fmt, va_list ap);\n```\n> \n> Same as json_printf, but prints to a file.\n> File is created if does not exist. File is truncated if already exists.\n>  \n",
    "lang": "c"
  },
  {
    "name": "json_asprintf",
    "file": "[frozen.h](https://github.com/cesanta/frozen/blob/master/frozen.h)",
    "doc": "\n```c\nchar *json_asprintf(const char *fmt, ...);\nchar *json_vasprintf(const char *fmt, va_list ap);\n```\n> \n> Print JSON into an allocated 0-terminated string.\n> Return allocated string, or NULL on error.\n> Example:\n> \n> ```c\n>   char *str = json_asprintf(\"{a:%H}\", 3, \"abc\");\n>   printf(\"%s\\n\", str);  // Prints \"616263\"\n>   free(str);\n> ```\n>  \n",
    "lang": "c"
  },
  {
    "name": "json_printf_array",
    "file": "[frozen.h](https://github.com/cesanta/frozen/blob/master/frozen.h)",
    "doc": "\n```c\nint json_printf_array(struct json_out *, va_list *ap);\n```\n> \n> Helper %M callback that prints contiguous C arrays.\n> Consumes void *array_ptr, size_t array_size, size_t elem_size, char *fmt\n> Return number of bytes printed.\n>  \n",
    "lang": "c"
  },
  {
    "name": "json_scanf",
    "file": "[frozen.h](https://github.com/cesanta/frozen/blob/master/frozen.h)",
    "doc": "\n```c\nint json_scanf(const char *str, int str_len, const char *fmt, ...);\nint json_vscanf(const char *str, int str_len, const char *fmt, va_list ap);\n```\n> \n> Scan JSON string `str`, performing scanf-like conversions according to `fmt`.\n> This is a `scanf()` - like function, with following differences:\n> \n> 1. Object keys in the format string may be not quoted, e.g. \"{key: %d}\"\n> 2. Order of keys in an object is irrelevant.\n> 3. Several extra format specifiers are supported:\n>    - %B: consumes `int *` (or `char *`, if `sizeof(bool) == sizeof(char)`),\n>       expects boolean `true` or `false`.\n>    - %Q: consumes `char **`, expects quoted, JSON-encoded string. Scanned\n>       string is malloc-ed, caller must free() the string.\n>    - %V: consumes `char **`, `int *`. Expects base64-encoded string.\n>       Result string is base64-decoded, malloced and NUL-terminated.\n>       The length of result string is stored in `int *` placeholder.\n>       Caller must free() the result.\n>    - %H: consumes `int *`, `char **`.\n>       Expects a hex-encoded string, e.g. \"fa014f\".\n>       Result string is hex-decoded, malloced and NUL-terminated.\n>       The length of the result string is stored in `int *` placeholder.\n>       Caller must free() the result.\n>    - %M: consumes custom scanning function pointer and\n>       `void *user_data` parameter - see json_scanner_t definition.\n>    - %T: consumes `struct json_token *`, fills it out with matched token.\n> \n> Return number of elements successfully scanned & converted.\n> Negative number means scan error.\n>  \n",
    "lang": "c"
  },
  {
    "name": "(*json_scanner_t)",
    "file": "[frozen.h](https://github.com/cesanta/frozen/blob/master/frozen.h)",
    "doc": "\n```c\ntypedef void (*json_scanner_t)(const char *str, int len, void *user_data);\n```\n>  json_scanf's %M handler  \n",
    "lang": "c"
  },
  {
    "name": "json_scanf_array_elem",
    "file": "[frozen.h](https://github.com/cesanta/frozen/blob/master/frozen.h)",
    "doc": "\n```c\nint json_scanf_array_elem(const char *s, int len, const char *path, int index,\n                          struct json_token *token);\n```\n> \n> Helper function to scan array item with given path and index.\n> Fills `token` with the matched JSON token.\n> Return -1 if no array element found, otherwise non-negative token length.\n>  \n",
    "lang": "c"
  },
  {
    "name": "json_unescape",
    "file": "[frozen.h](https://github.com/cesanta/frozen/blob/master/frozen.h)",
    "doc": "\n```c\nint json_unescape(const char *src, int slen, char *dst, int dlen);\n```\n> \n> Unescape JSON-encoded string src,slen into dst, dlen.\n> src and dst may overlap.\n> If destination buffer is too small (or zero-length), result string is not\n> written but the length is counted nevertheless (similar to snprintf).\n> Return the length of unescaped string in bytes.\n>  \n",
    "lang": "c"
  },
  {
    "name": "json_escape",
    "file": "[frozen.h](https://github.com/cesanta/frozen/blob/master/frozen.h)",
    "doc": "\n```c\nint json_escape(struct json_out *out, const char *str, size_t str_len);\n```\n> \n> Escape a string `str`, `str_len` into the printer `out`.\n> Return the number of bytes printed.\n>  \n",
    "lang": "c"
  },
  {
    "name": "json_fread",
    "file": "[frozen.h](https://github.com/cesanta/frozen/blob/master/frozen.h)",
    "doc": "\n```c\nchar *json_fread(const char *file_name);\n```\n> \n> Read the whole file in memory.\n> Return malloc-ed file content, or NULL on error. The caller must free().\n>  \n",
    "lang": "c"
  },
  {
    "name": "json_setf",
    "file": "[frozen.h](https://github.com/cesanta/frozen/blob/master/frozen.h)",
    "doc": "\n```c\nint json_setf(const char *s, int len, struct json_out *out,\n              const char *json_path, const char *json_fmt, ...);\n```\n> \n> Update given JSON string `s,len` by changing the value at given `json_path`.\n> The result is saved to `out`. If `json_fmt` == NULL, that deletes the key.\n> If path is not present, missing keys are added. Array path without an\n> index pushes a value to the end of an array.\n> Return 1 if the string was changed, 0 otherwise.\n> \n> Example:  s is a JSON string { \"a\": 1, \"b\": [ 2 ] }\n>   json_setf(s, len, out, \".a\", \"7\");     // { \"a\": 7, \"b\": [ 2 ] }\n>   json_setf(s, len, out, \".b\", \"7\");     // { \"a\": 1, \"b\": 7 }\n>   json_setf(s, len, out, \".b[]\", \"7\");   // { \"a\": 1, \"b\": [ 2,7 ] }\n>   json_setf(s, len, out, \".b\", NULL);    // { \"a\": 1 }\n>  \n",
    "lang": "c"
  },
  {
    "name": "json_prettify",
    "file": "[frozen.h](https://github.com/cesanta/frozen/blob/master/frozen.h)",
    "doc": "\n```c\nint json_prettify(const char *s, int len, struct json_out *out);\n```\n> \n> Pretty-print JSON string `s,len` into `out`.\n> Return number of processed bytes in `s`.\n>  \n",
    "lang": "c"
  },
  {
    "name": "json_prettify_file",
    "file": "[frozen.h](https://github.com/cesanta/frozen/blob/master/frozen.h)",
    "doc": "\n```c\nint json_prettify_file(const char *file_name);\n```\n> \n> Prettify JSON file `file_name`.\n> Return number of processed bytes, or negative number of error.\n> On error, file content is not modified.\n>  \n",
    "lang": "c"
  },
  {
    "name": "json_next_key",
    "file": "[frozen.h](https://github.com/cesanta/frozen/blob/master/frozen.h)",
    "doc": "\n```c\nvoid *json_next_key(const char *s, int len, void *handle, const char *path,\n                    struct json_token *key, struct json_token *val);\n```\n> \n> Iterate over an object at given JSON `path`.\n> On each iteration, fill the `key` and `val` tokens. It is OK to pass NULL\n> for `key`, or `val`, in which case they won't be populated.\n> Return an opaque value suitable for the next iteration, or NULL when done.\n> \n> Example:\n> \n> ```c\n> void *h = NULL;\n> struct json_token key, val;\n> while ((h = json_next_key(s, len, h, \".foo\", &key, &val)) != NULL) {\n>   printf(\"[%.*s] -> [%.*s]\\n\", key.len, key.ptr, val.len, val.ptr);\n> }\n> ```\n>  \n",
    "lang": "c"
  },
  {
    "name": "json_next_elem",
    "file": "[frozen.h](https://github.com/cesanta/frozen/blob/master/frozen.h)",
    "doc": "\n```c\nvoid *json_next_elem(const char *s, int len, void *handle, const char *path,\n                     int *idx, struct json_token *val);\n```\n> \n> Iterate over an array at given JSON `path`.\n> Similar to `json_next_key`, but fills array index `idx` instead of `key`.\n>  \n",
    "lang": "c"
  },
  {
    "name": "cs_log_set_level",
    "file": "[cs_dbg.h](https://github.com/cesanta/mongoose-os/blob/master/include/cs_dbg.h)",
    "doc": "\n```c\nvoid cs_log_set_level(enum cs_log_level level);\n```\n> \n> Set max log level to print; messages with the level above the given one will\n> not be printed.\n>  \n",
    "lang": "c"
  },
  {
    "name": "cs_log_set_file_level",
    "file": "[cs_dbg.h](https://github.com/cesanta/mongoose-os/blob/master/include/cs_dbg.h)",
    "doc": "\n```c\nvoid cs_log_set_file_level(const char *file_level);\n```\n> \n> A comma-separated set of prefix=level.\n> prefix is matched against the log prefix exactly as printed, including line\n> number, but partial match is ok. Check stops on first matching entry.\n> If nothing matches, default level is used.\n> \n> Examples:\n>   main.c:=4 - everything from main C at verbose debug level.\n>   mongoose.c=1,mjs.c=1,=4 - everything at verbose debug except mg_* and mjs_*\n> \n>  \n",
    "lang": "c"
  },
  {
    "name": "cs_log_print_prefix",
    "file": "[cs_dbg.h](https://github.com/cesanta/mongoose-os/blob/master/include/cs_dbg.h)",
    "doc": "\n```c\nint cs_log_print_prefix(enum cs_log_level level, const char *fname, int line);\n```\n> \n> Helper function which prints message prefix with the given `level`.\n> If message should be printed (according to the current log level\n> and filter), prints the prefix and returns 1, otherwise returns 0.\n> \n> Clients should typically just use `LOG()` macro.\n>  \n",
    "lang": "c"
  },
  {
    "name": "cs_log_set_file",
    "file": "[cs_dbg.h](https://github.com/cesanta/mongoose-os/blob/master/include/cs_dbg.h)",
    "doc": "\n```c\nvoid cs_log_set_file(FILE *file);\n```\n> \n> Set file to write logs into. If `NULL`, logs go to `stderr`.\n>  \n",
    "lang": "c"
  },
  {
    "name": "cs_log_printf",
    "file": "[cs_dbg.h](https://github.com/cesanta/mongoose-os/blob/master/include/cs_dbg.h)",
    "doc": "\n```c\nvoid cs_log_printf(const char *fmt, ...) PRINTF_LIKE(1, 2);\n```\n> \n> Prints log to the current log file, appends \"\\n\" in the end and flushes the\n> stream.\n>  \n",
    "lang": "c"
  },
  {
    "name": "LOG",
    "file": "[cs_dbg.h](https://github.com/cesanta/mongoose-os/blob/master/include/cs_dbg.h)",
    "doc": "\n```c\n#define LOG(l, x)                                     \\\n  do {                                                \\\n    if (cs_log_print_prefix(l, __FILE__, __LINE__)) { \\\n      cs_log_printf x;                                \\\n    }                                                 \\\n  } while (0)\n```\n> \n> Format and print message `x` with the given level `l`. Example:\n> \n> ```c\n> LOG(LL_INFO, (\"my info message: %d\", 123));\n> LOG(LL_DEBUG, (\"my debug message: %d\", 123));\n> ```\n>  \n",
    "lang": "c"
  },
  {
    "name": "DBG",
    "file": "[cs_dbg.h](https://github.com/cesanta/mongoose-os/blob/master/include/cs_dbg.h)",
    "doc": "\n```c\n#define DBG(x) LOG(LL_VERBOSE_DEBUG, x)\n```\n> \n> Shortcut for `LOG(LL_VERBOSE_DEBUG, (...))`\n>  \n",
    "lang": "c"
  },
  {
    "name": "DBG",
    "file": "[cs_dbg.h](https://github.com/cesanta/mongoose-os/blob/master/include/cs_dbg.h)",
    "doc": "\n```c\n#define DBG(x)\n```\n>  NDEBUG \n",
    "lang": "c"
  },
  {
    "name": "LOG",
    "file": "[cs_dbg.h](https://github.com/cesanta/mongoose-os/blob/master/include/cs_dbg.h)",
    "doc": "\n```c\n#define LOG(l, x)\n#define DBG(x)\n```\n>  CS_ENABLE_STDIO \n",
    "lang": "c"
  },
  {
    "name": "mbuf_init",
    "file": "[mbuf.h](https://github.com/cesanta/mongoose-os/blob/master/include/mbuf.h)",
    "doc": "\n```c\nvoid mbuf_init(struct mbuf *, size_t initial_capacity);\n```\n> \n> Initialises an Mbuf.\n> `initial_capacity` specifies the initial capacity of the mbuf.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mbuf_free",
    "file": "[mbuf.h](https://github.com/cesanta/mongoose-os/blob/master/include/mbuf.h)",
    "doc": "\n```c\nvoid mbuf_free(struct mbuf *);\n```\n>  Frees the space allocated for the mbuffer and resets the mbuf structure. \n",
    "lang": "c"
  },
  {
    "name": "mbuf_append",
    "file": "[mbuf.h](https://github.com/cesanta/mongoose-os/blob/master/include/mbuf.h)",
    "doc": "\n```c\nsize_t mbuf_append(struct mbuf *, const void *data, size_t data_size);\n```\n> \n> Appends data to the Mbuf.\n> \n> Returns the number of bytes appended or 0 if out of memory.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mbuf_append_and_free",
    "file": "[mbuf.h](https://github.com/cesanta/mongoose-os/blob/master/include/mbuf.h)",
    "doc": "\n```c\nsize_t mbuf_append_and_free(struct mbuf *, void *data, size_t data_size);\n```\n> \n> Appends data to the Mbuf and frees it (data must be heap-allocated).\n> \n> Returns the number of bytes appended or 0 if out of memory.\n> data is freed irrespective of return value.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mbuf_insert",
    "file": "[mbuf.h](https://github.com/cesanta/mongoose-os/blob/master/include/mbuf.h)",
    "doc": "\n```c\nsize_t mbuf_insert(struct mbuf *, size_t, const void *, size_t);\n```\n> \n> Inserts data at a specified offset in the Mbuf.\n> \n> Existing data will be shifted forwards and the buffer will\n> be grown if necessary.\n> Returns the number of bytes inserted.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mbuf_remove",
    "file": "[mbuf.h](https://github.com/cesanta/mongoose-os/blob/master/include/mbuf.h)",
    "doc": "\n```c\nvoid mbuf_remove(struct mbuf *, size_t data_size);\n```\n>  Removes `data_size` bytes from the beginning of the buffer. \n",
    "lang": "c"
  },
  {
    "name": "mbuf_resize",
    "file": "[mbuf.h](https://github.com/cesanta/mongoose-os/blob/master/include/mbuf.h)",
    "doc": "\n```c\nvoid mbuf_resize(struct mbuf *, size_t new_size);\n```\n> \n> Resizes an Mbuf.\n> \n> If `new_size` is smaller than buffer's `len`, the\n> resize is not performed.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mbuf_move",
    "file": "[mbuf.h](https://github.com/cesanta/mongoose-os/blob/master/include/mbuf.h)",
    "doc": "\n```c\nvoid mbuf_move(struct mbuf *from, struct mbuf *to);\n```\n>  Moves the state from one mbuf to the other. \n",
    "lang": "c"
  },
  {
    "name": "mbuf_clear",
    "file": "[mbuf.h](https://github.com/cesanta/mongoose-os/blob/master/include/mbuf.h)",
    "doc": "\n```c\nvoid mbuf_clear(struct mbuf *);\n```\n>  Removes all the data from mbuf (if any). \n",
    "lang": "c"
  },
  {
    "name": "mbuf_trim",
    "file": "[mbuf.h](https://github.com/cesanta/mongoose-os/blob/master/include/mbuf.h)",
    "doc": "\n```c\nvoid mbuf_trim(struct mbuf *);\n```\n>  Shrinks an Mbuf by resizing its `size` to `len`. \n",
    "lang": "c"
  },
  {
    "name": "mg_mk_str",
    "file": "[mg_str.h](https://github.com/cesanta/mongoose-os/blob/master/include/mg_str.h)",
    "doc": "\n```c\nstruct mg_str mg_mk_str(const char *s);\n```\n> \n> Helper function for creating mg_str struct from plain C string.\n> `NULL` is allowed and becomes `{NULL, 0}`.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mg_mk_str_n",
    "file": "[mg_str.h](https://github.com/cesanta/mongoose-os/blob/master/include/mg_str.h)",
    "doc": "\n```c\nstruct mg_str mg_mk_str_n(const char *s, size_t len);\n```\n> \n> Like `mg_mk_str`, but takes string length explicitly.\n>  \n",
    "lang": "c"
  },
  {
    "name": "MG_MK_STR",
    "file": "[mg_str.h](https://github.com/cesanta/mongoose-os/blob/master/include/mg_str.h)",
    "doc": "\n```c\n#define MG_MK_STR(str_literal) \\\n  { str_literal, sizeof(str_literal) - 1 }\n#define MG_MK_STR_N(str_literal, len) \\\n  { str_literal, len }\n#define MG_NULL_STR \\\n  { NULL, 0 }\n```\n>  Macro for initializing mg_str. \n",
    "lang": "c"
  },
  {
    "name": "mg_vcmp",
    "file": "[mg_str.h](https://github.com/cesanta/mongoose-os/blob/master/include/mg_str.h)",
    "doc": "\n```c\nint mg_vcmp(const struct mg_str *str2, const char *str1);\n```\n> \n> Cross-platform version of `strcmp()` where where first string is\n> specified by `struct mg_str`.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mg_vcasecmp",
    "file": "[mg_str.h](https://github.com/cesanta/mongoose-os/blob/master/include/mg_str.h)",
    "doc": "\n```c\nint mg_vcasecmp(const struct mg_str *str2, const char *str1);\n```\n> \n> Cross-platform version of `strncasecmp()` where first string is\n> specified by `struct mg_str`.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mg_strdup",
    "file": "[mg_str.h](https://github.com/cesanta/mongoose-os/blob/master/include/mg_str.h)",
    "doc": "\n```c\nstruct mg_str mg_strdup(const struct mg_str s);\n```\n>  Creates a copy of s (heap-allocated). \n",
    "lang": "c"
  },
  {
    "name": "mg_strdup_nul",
    "file": "[mg_str.h](https://github.com/cesanta/mongoose-os/blob/master/include/mg_str.h)",
    "doc": "\n```c\nstruct mg_str mg_strdup_nul(const struct mg_str s);\n```\n> \n> Creates a copy of s (heap-allocated).\n> Resulting string is NUL-terminated (but NUL is not included in len).\n>  \n",
    "lang": "c"
  },
  {
    "name": "mg_strchr",
    "file": "[mg_str.h](https://github.com/cesanta/mongoose-os/blob/master/include/mg_str.h)",
    "doc": "\n```c\nconst char *mg_strchr(const struct mg_str s, int c);\n```\n> \n> Locates character in a string.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mg_strcmp",
    "file": "[mg_str.h](https://github.com/cesanta/mongoose-os/blob/master/include/mg_str.h)",
    "doc": "\n```c\nint mg_strcmp(const struct mg_str str1, const struct mg_str str2);\n```\n> \n> Compare two `mg_str`s; return value is the same as `strcmp`.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mg_strncmp",
    "file": "[mg_str.h](https://github.com/cesanta/mongoose-os/blob/master/include/mg_str.h)",
    "doc": "\n```c\nint mg_strncmp(const struct mg_str str1, const struct mg_str str2, size_t n);\n```\n> \n> Like `mg_strcmp`, but compares at most `n` characters.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mg_strcasecmp",
    "file": "[mg_str.h](https://github.com/cesanta/mongoose-os/blob/master/include/mg_str.h)",
    "doc": "\n```c\nint mg_strcasecmp(const struct mg_str str1, const struct mg_str str2);\n```\n> \n> Compare two `mg_str`s ignoreing case; return value is the same as `strcmp`.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mg_strfree",
    "file": "[mg_str.h](https://github.com/cesanta/mongoose-os/blob/master/include/mg_str.h)",
    "doc": "\n```c\nvoid mg_strfree(struct mg_str *s);\n```\n> \n> Free the string (assuming it was heap allocated).\n>  \n",
    "lang": "c"
  },
  {
    "name": "mg_strstr",
    "file": "[mg_str.h](https://github.com/cesanta/mongoose-os/blob/master/include/mg_str.h)",
    "doc": "\n```c\nconst char *mg_strstr(const struct mg_str haystack, const struct mg_str needle);\n```\n> \n> Finds the first occurrence of a substring `needle` in the `haystack`.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mg_strstrip",
    "file": "[mg_str.h](https://github.com/cesanta/mongoose-os/blob/master/include/mg_str.h)",
    "doc": "\n```c\nstruct mg_str mg_strstrip(struct mg_str s);\n```\n>  Strip whitespace at the start and the end of s \n",
    "lang": "c"
  },
  {
    "name": "mg_str_starts_with",
    "file": "[mg_str.h](https://github.com/cesanta/mongoose-os/blob/master/include/mg_str.h)",
    "doc": "\n```c\nint mg_str_starts_with(struct mg_str s, struct mg_str prefix);\n```\n>  Returns 1 if s starts with the given prefix. \n",
    "lang": "c"
  },
  {
    "name": "mgos_adc_enable",
    "file": "[mgos_adc.h](https://github.com/mongoose-os-libs/adc/blob/master/include/mgos_adc.h)",
    "doc": "\n```c\nbool mgos_adc_enable(int pin);\n```\n>  Configure and enable ADC \n",
    "lang": "c"
  },
  {
    "name": "mgos_adc_read",
    "file": "[mgos_adc.h](https://github.com/mongoose-os-libs/adc/blob/master/include/mgos_adc.h)",
    "doc": "\n```c\nint mgos_adc_read(int pin);\n```\n>  Read from the analog pin. Returns raw value. \n",
    "lang": "c"
  },
  {
    "name": "mgos_adc_read_voltage",
    "file": "[mgos_adc.h](https://github.com/mongoose-os-libs/adc/blob/master/include/mgos_adc.h)",
    "doc": "\n```c\nint mgos_adc_read_voltage(int pin);\n```\n> \n> Read from the specified analog pin.\n> Returns voltage on the pin, in mV.\n>  \n",
    "lang": "c"
  },
  {
    "name": "ADC.enable(pin)",
    "file": "[api_adc.js](https://github.com/mongoose-os-libs/adc/blob/master/mjs_fs/api_adc.js)",
    "doc": "\n```javascript\nADC.enable(pin)\n```\nConfigure and enable ADC for a `pin`,\nreturn 1 if success, 0 otherwise.\n",
    "lang": "js"
  },
  {
    "name": "ADC.read(pin)",
    "file": "[api_adc.js](https://github.com/mongoose-os-libs/adc/blob/master/mjs_fs/api_adc.js)",
    "doc": "\n```javascript\nADC.read(pin)\n```\nRead `pin` analog value, return an integer.\n\nNote for ESP8266 platform:\nwith this function, you can also measure the power voltage\nof VDD33 pin 3 and 4. Then:\n1) TOUT pin has to be floating in the circuit\n\t(not connected to anything);\n2) In mos.yaml must be set this feature:\n\tbuild_vars:\n\t\tMGOS_ADC_MODE_VDD: 1\n3) The return value may be different in different Wi-Fi modes,\n\tfor example, in Modem-sleep mode or in normal Wi-Fi working\n\tmode.\nReturn value: Power voltage of VDD33; unit: 1/1024 V.\n",
    "lang": "js"
  },
  {
    "name": "mgos_ads1x1x_create",
    "file": "[mgos_ads1x1x.h](https://github.com/mongoose-os-libs/ads1x1x-i2c/blob/master/include/mgos_ads1x1x.h)",
    "doc": "\n```c\nstruct mgos_ads1x1x *mgos_ads1x1x_create(struct mgos_i2c *i2c, uint8_t i2caddr, enum mgos_ads1x1x_type type);\n```\n> \n> Initialize a ADS1X1X on the I2C bus `i2c` at address specified in `i2caddr`\n> parameter (default ADS1X1X is on address 0x48). The device will be polled for\n> validity, upon success a new `struct mgos_ads1x1x` is allocated and\n> returned. If the device could not be found, NULL is returned.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_ads1x1x_destroy",
    "file": "[mgos_ads1x1x.h](https://github.com/mongoose-os-libs/ads1x1x-i2c/blob/master/include/mgos_ads1x1x.h)",
    "doc": "\n```c\nbool mgos_ads1x1x_destroy(struct mgos_ads1x1x **dev);\n```\n> \n> Destroy the data structure associated with a ADS1X1X device. The reference\n> to the pointer of the `struct mgos_ads1x1x` has to be provided, and upon\n> successful destruction, its associated memory will be freed and the pointer\n> set to NULL and true will be returned.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_ads1x1x_set_fsr",
    "file": "[mgos_ads1x1x.h](https://github.com/mongoose-os-libs/ads1x1x-i2c/blob/master/include/mgos_ads1x1x.h)",
    "doc": "\n```c\nbool mgos_ads1x1x_set_fsr(struct mgos_ads1x1x *dev, enum mgos_ads1x1x_fsr fsr);\nbool mgos_ads1x1x_get_fsr(struct mgos_ads1x1x *dev, enum mgos_ads1x1x_fsr *fsr);\n```\n>  Get or Set the Full Scale Range (FSR). All chips in the ADS1X1X family support\n> the same settings. By default, 2.048V is used.\n> \n> Note: ADS1x13 does not support this, and always has an FSR of 2.048V.\n> \n> Returns true on success, false otherwise.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_ads1x1x_set_dr",
    "file": "[mgos_ads1x1x.h](https://github.com/mongoose-os-libs/ads1x1x-i2c/blob/master/include/mgos_ads1x1x.h)",
    "doc": "\n```c\nbool mgos_ads1x1x_set_dr(struct mgos_ads1x1x *dev, enum mgos_ads1x1x_dr dr);\nbool mgos_ads1x1x_get_dr(struct mgos_ads1x1x *dev, enum mgos_ads1x1x_dr *dr);\n```\n>  Get or Set the Data Rate (in Samples per Second). If the supplied `dr`\n> argument cannot be set on the chip, false is returned. Otherwise, the\n> supplied `dr` is set. By default, ADS101X sets 1600SPS, ADS111X sets 128SPS.\n> \n> Returns true on success, false otherwise.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_ads1x1x_read",
    "file": "[mgos_ads1x1x.h](https://github.com/mongoose-os-libs/ads1x1x-i2c/blob/master/include/mgos_ads1x1x.h)",
    "doc": "\n```c\nbool mgos_ads1x1x_read(struct mgos_ads1x1x *dev, uint8_t chan, int16_t *result);\n```\n>  Read a channel from the ADC and return the read value in `result`. If the\n> channel was invalid, or an error occurred, false is returned and the result\n> cannot be relied upon.\n> \n> Returns true on success, false otherwise.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_ads1x1x_read_diff",
    "file": "[mgos_ads1x1x.h](https://github.com/mongoose-os-libs/ads1x1x-i2c/blob/master/include/mgos_ads1x1x.h)",
    "doc": "\n```c\nbool mgos_ads1x1x_read_diff(struct mgos_ads1x1x *dev, uint8_t chanP, uint8_t chanN, int16_t *result);\n```\n>  Read a 2-channel differential from the ADC and return the read value in `result`.\n> If the channel pair invalid, or an error occurred, false is returned and the\n> result cannot be relied upon. Upon success, true is returned.\n> \n> Note: This is only available on ADS1X15 chips.\n>       Valid chanP/chanN pairs are : 0/1, 0/3, 1/3, 2/3.\n> \n> Returns true on success, false otherwise.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_apds9960_create",
    "file": "[mgos_apds9960.h](https://github.com/mongoose-os-libs/apds9960-i2c/blob/master/include/mgos_apds9960.h)",
    "doc": "\n```c\nstruct mgos_apds9960 *mgos_apds9960_create(struct mgos_i2c *i2c, uint8_t i2caddr);\n```\n> \n> Initialize a APDS9960 on the I2C bus `i2c` at address specified in `i2caddr`\n> parameter (default APDS9960 is on address 0x39). The sensor will be polled for\n> validity, upon success a new `struct mgos_apds9960` is allocated and\n> returned. If the device could not be found, NULL is returned.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_apds9960_destroy",
    "file": "[mgos_apds9960.h](https://github.com/mongoose-os-libs/apds9960-i2c/blob/master/include/mgos_apds9960.h)",
    "doc": "\n```c\nvoid mgos_apds9960_destroy(struct mgos_apds9960 **sensor);\n```\n> \n> Destroy the data structure associated with a APDS9960 device. The reference\n> to the pointer of the `struct mgos_apds9960` has to be provided, and upon\n> successful destruction, its associated memory will be freed and the pointer\n> set to NULL.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_apds9960_set_callback_light",
    "file": "[mgos_apds9960.h](https://github.com/mongoose-os-libs/apds9960-i2c/blob/master/include/mgos_apds9960.h)",
    "doc": "\n```c\nbool mgos_apds9960_set_callback_light(struct mgos_apds9960 *sensor, uint16_t low_threshold, uint16_t high_threshold, mgos_apds9960_light_event_t handler);\nbool mgos_apds9960_set_callback_proximity(struct mgos_apds9960 *sensor, uint8_t low_threshold, uint8_t high_threshold, mgos_apds9960_proximity_event_t handler);\nbool mgos_apds9960_set_callback_gesture(struct mgos_apds9960 *sensor, mgos_apds9960_gesture_event_t handler);\n```\n> \n> Install an interrupt (see `mos.yml` key `apds9960.irq_pin`), and when the\n> interrupt is asserted, call a callback for `light`, `proximity` and/or\n> `gesture` events.\n> \n> For light: `low_threshold` and `high_threshold` arguments determine between\n> which values on the `clear` (ambient) light channel an interrupt is generated.\n> \n> For proximity: `low_threshold` and `high_threshold` arguments determine between\n> which values on the `proximity` channel an interrupt is generated. Note: high\n> values are closer to the sensor, low values are further away.\n> \n> Returns true on success, or false otherwise.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_apds9960_read_light",
    "file": "[mgos_apds9960.h](https://github.com/mongoose-os-libs/apds9960-i2c/blob/master/include/mgos_apds9960.h)",
    "doc": "\n```c\nbool mgos_apds9960_read_light(struct mgos_apds9960 *sensor, uint16_t *clear, uint16_t *red, uint16_t *green, uint16_t *blue);\n```\n> \n> Read the clear (ambient), red, green, and blue light values from the sensor.\n> Lower values mean less light was detected. The arguments clear, red, green\n> and blue may be NULL, in which case they are not polled from the sensor.\n> Returns true on success, or false otherwise. If false is returned, the\n> values of clear, red, green and blue cannot be used.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_apds9960_read_proximity",
    "file": "[mgos_apds9960.h](https://github.com/mongoose-os-libs/apds9960-i2c/blob/master/include/mgos_apds9960.h)",
    "doc": "\n```c\nbool mgos_apds9960_read_proximity(struct mgos_apds9960 *sensor, uint8_t *proximity);\n```\n> \n> Read the proximity value from the sensor. Lower values mean further away,\n> higher values mean closer to the sensor.\n> Returns true on success, or false otherwise. If false is returned, the\n> value of proximity cannot be used.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_apds9960_is_gesture_available",
    "file": "[mgos_apds9960.h](https://github.com/mongoose-os-libs/apds9960-i2c/blob/master/include/mgos_apds9960.h)",
    "doc": "\n```c\nbool mgos_apds9960_is_gesture_available(struct mgos_apds9960 *sensor);\n```\n> \n> Return true if the gesture sensor has available data in its FIFO buffer.\n>  \n",
    "lang": "c"
  },
  {
    "name": "Adafruit_ADS1015.create(i2cAddress)",
    "file": "[api_ads1015.js](https://github.com/mongoose-os-libs/arduino-adafruit-ads1x15/blob/master/mjs_fs/api_ads1015.js)",
    "doc": "\n```javascript\nAdafruit_ADS1015.create(i2cAddress)\n```\nCreate an ADS1015 instance: an object with the methods described below.\n`i2cAddress` is an I2C address of the ADS1015.\n",
    "lang": "js"
  },
  {
    "name": "Adafruit_ADS1115.create(i2cAddress)",
    "file": "[api_ads1015.js](https://github.com/mongoose-os-libs/arduino-adafruit-ads1x15/blob/master/mjs_fs/api_ads1015.js)",
    "doc": "\n```javascript\nAdafruit_ADS1115.create(i2cAddress)\n```\nCreate an ADS1115 instance: an object with the methods described below.\n`i2cAddress` is an I2C address of the ADS1115.\n",
    "lang": "js"
  },
  {
    "name": "myADS.close()",
    "file": "[api_ads1015.js](https://github.com/mongoose-os-libs/arduino-adafruit-ads1x15/blob/master/mjs_fs/api_ads1015.js)",
    "doc": "\n```javascript\nmyADS.close()\n```\nClose an instance; no methods can be called on this instance after that.\nReturn value: none.\n",
    "lang": "js"
  },
  {
    "name": "myADS.begin()",
    "file": "[api_ads1015.js](https://github.com/mongoose-os-libs/arduino-adafruit-ads1x15/blob/master/mjs_fs/api_ads1015.js)",
    "doc": "\n```javascript\nmyADS.begin()\n```\nSet up the ADS1015/ADS1115 hardware\n",
    "lang": "js"
  },
  {
    "name": "myADS.readADC_SingleEnded(channel)",
    "file": "[api_ads1015.js](https://github.com/mongoose-os-libs/arduino-adafruit-ads1x15/blob/master/mjs_fs/api_ads1015.js)",
    "doc": "\n```javascript\nmyADS.readADC_SingleEnded(channel)\n```\nGet a single-ended ADC reading from the given `channel`.\n",
    "lang": "js"
  },
  {
    "name": "myADS.readADC_Differential_0_1()",
    "file": "[api_ads1015.js](https://github.com/mongoose-os-libs/arduino-adafruit-ads1x15/blob/master/mjs_fs/api_ads1015.js)",
    "doc": "\n```javascript\nmyADS.readADC_Differential_0_1()\n```\nRead the conversion results, measuring the difference between the P\n(AIN0) and N (AIN1) input. Returns a signed value since the difference\ncan be either positive or negative.\n",
    "lang": "js"
  },
  {
    "name": "myADS.readADC_Differential_0_1()",
    "file": "[api_ads1015.js](https://github.com/mongoose-os-libs/arduino-adafruit-ads1x15/blob/master/mjs_fs/api_ads1015.js)",
    "doc": "\n```javascript\nmyADS.readADC_Differential_0_1()\n```\nRead the conversion results, measuring the difference between the P\n(AIN2) and N (AIN3) input. Returns a signed value since the difference\ncan be either positive or negative.\n",
    "lang": "js"
  },
  {
    "name": "myADS.startComparator_SingleEnded(channel, threshold)",
    "file": "[api_ads1015.js](https://github.com/mongoose-os-libs/arduino-adafruit-ads1x15/blob/master/mjs_fs/api_ads1015.js)",
    "doc": "\n```javascript\nmyADS.startComparator_SingleEnded(channel, threshold)\n```\nSet up the comparator to operate in basic mode, causing the ALERT/RDY\npin to assert (go from high to low) when the ADC value exceeds the\nspecified `threshold`.\nReturn value: none.\n",
    "lang": "js"
  },
  {
    "name": "myADS.getLastConversionResults()",
    "file": "[api_ads1015.js](https://github.com/mongoose-os-libs/arduino-adafruit-ads1x15/blob/master/mjs_fs/api_ads1015.js)",
    "doc": "\n```javascript\nmyADS.getLastConversionResults()\n```\nIn order to clear the comparator, we need to read the conversion\nresults.  This function reads the last conversion results without\nchanging the config value.\n",
    "lang": "js"
  },
  {
    "name": "myADS.setGain(gain)",
    "file": "[api_ads1015.js](https://github.com/mongoose-os-libs/arduino-adafruit-ads1x15/blob/master/mjs_fs/api_ads1015.js)",
    "doc": "\n```javascript\nmyADS.setGain(gain)\n```\nSet the gain and input voltage range; one of the following:\n\n- `Adafruit_ADS1015.GAIN_TWOTHIRDS`\n- `Adafruit_ADS1015.GAIN_ONE`\n- `Adafruit_ADS1015.GAIN_TWO`\n- `Adafruit_ADS1015.GAIN_FOUR`\n- `Adafruit_ADS1015.GAIN_EIGHT`\n- `Adafruit_ADS1015.GAIN_SIXTEEN`\n\nReturn value: none.\n",
    "lang": "js"
  },
  {
    "name": "readS16_LE",
    "file": "[Adafruit_BME280.h](https://github.com/mongoose-os-libs/arduino-adafruit-bme280/blob/master/include/Adafruit_BME280.h)",
    "doc": "\n```c\nint16_t   readS16_LE(byte reg); // little endian\n```\n> little endian\n",
    "lang": "c"
  },
  {
    "name": "Adafruit_BME280.createI2C(i2caddr)",
    "file": "[api_arduino_bme280.js](https://github.com/mongoose-os-libs/arduino-adafruit-bme280/blob/master/mjs_fs/api_arduino_bme280.js)",
    "doc": "\n```javascript\nAdafruit_BME280.createI2C(i2caddr)\n```\nCreate a BME280 instance on I2C bus with the given address `i2caddr`.\nReturn value: an object with the methods described below.\n",
    "lang": "js"
  },
  {
    "name": "Adafruit_BME280.createSPI(cspin)",
    "file": "[api_arduino_bme280.js](https://github.com/mongoose-os-libs/arduino-adafruit-bme280/blob/master/mjs_fs/api_arduino_bme280.js)",
    "doc": "\n```javascript\nAdafruit_BME280.createSPI(cspin)\n```\nCreate a BME280 instance on SPI bus with the given Chip Select pin `cspin`.\nReturn value: an object with the methods described below.\n",
    "lang": "js"
  },
  {
    "name": "Adafruit_BME280.createSPIFull(cspin, mosipin, misopin, sckpin)",
    "file": "[api_arduino_bme280.js](https://github.com/mongoose-os-libs/arduino-adafruit-bme280/blob/master/mjs_fs/api_arduino_bme280.js)",
    "doc": "\n```javascript\nAdafruit_BME280.createSPIFull(cspin, mosipin, misopin, sckpin)\n```\nCreate a BME280 instance on SPI bus with the given pins `cspin`,\n`mosipin`, `misopin`, `sckpin`.\nReturn value: an object with the methods described below.\n",
    "lang": "js"
  },
  {
    "name": "myBME.close()",
    "file": "[api_arduino_bme280.js](https://github.com/mongoose-os-libs/arduino-adafruit-bme280/blob/master/mjs_fs/api_arduino_bme280.js)",
    "doc": "\n```javascript\nmyBME.close()\n```\nClose Adafruit_BME280 instance; no methods can be called on this instance\nafter that.\nReturn value: none.\n",
    "lang": "js"
  },
  {
    "name": "myBME.takeForcedMeasurement()",
    "file": "[api_arduino_bme280.js](https://github.com/mongoose-os-libs/arduino-adafruit-bme280/blob/master/mjs_fs/api_arduino_bme280.js)",
    "doc": "\n```javascript\nmyBME.takeForcedMeasurement()\n```\nTake a new measurement (only possible in forced mode).\n",
    "lang": "js"
  },
  {
    "name": "myBME.readTemperature()",
    "file": "[api_arduino_bme280.js](https://github.com/mongoose-os-libs/arduino-adafruit-bme280/blob/master/mjs_fs/api_arduino_bme280.js)",
    "doc": "\n```javascript\nmyBME.readTemperature()\n```\nReturn the temperature from the sensor in degrees C or\n`Adafruit_BME280.RES_FAIL` in case of a failure.\n",
    "lang": "js"
  },
  {
    "name": "myBME.readPressure()",
    "file": "[api_arduino_bme280.js](https://github.com/mongoose-os-libs/arduino-adafruit-bme280/blob/master/mjs_fs/api_arduino_bme280.js)",
    "doc": "\n```javascript\nmyBME.readPressure()\n```\nReturns the pressure from the sensor in hPa\nor `Adafruit_BME280.RES_FAIL` in case of a failure.\n",
    "lang": "js"
  },
  {
    "name": "myBME.readHumidity()",
    "file": "[api_arduino_bme280.js](https://github.com/mongoose-os-libs/arduino-adafruit-bme280/blob/master/mjs_fs/api_arduino_bme280.js)",
    "doc": "\n```javascript\nmyBME.readHumidity()\n```\nReturns the humidity from the sensor in %RH\nor `Adafruit_BME280.RES_FAIL` in case of a failure.\n",
    "lang": "js"
  },
  {
    "name": "myBME.readAltitude(seaLevel)",
    "file": "[api_arduino_bme280.js](https://github.com/mongoose-os-libs/arduino-adafruit-bme280/blob/master/mjs_fs/api_arduino_bme280.js)",
    "doc": "\n```javascript\nmyBME.readAltitude(seaLevel)\n```\nReturns the altitude in meters calculated from the specified\nsea-level pressure `seaLevel` (in hPa)\nor `Adafruit_BME280.RES_FAIL` in case of a failure.\nhttp://www.adafruit.com/datasheets/BST-BMP180-DS000-09.pdf, P.16\n",
    "lang": "js"
  },
  {
    "name": "myBME.seaLevelForAltitude(alt, pres)",
    "file": "[api_arduino_bme280.js](https://github.com/mongoose-os-libs/arduino-adafruit-bme280/blob/master/mjs_fs/api_arduino_bme280.js)",
    "doc": "\n```javascript\nmyBME.seaLevelForAltitude(alt, pres)\n```\nReturns the pressure at sea level in hPa\ncalculated from the specified altitude `alt` (in meters),\nand atmospheric pressure `pres` (in hPa)\nor `Adafruit_BME280.RES_FAIL` in case of a failure.\nhttp://www.adafruit.com/datasheets/BST-BMP180-DS000-09.pdf, P.17\n",
    "lang": "js"
  },
  {
    "name": "writeRAMCommand",
    "file": "[Adafruit_EPD.h](https://github.com/mongoose-os-libs/arduino-adafruit-epd/blob/master/include/Adafruit_EPD.h)",
    "doc": "\n```c\nvirtual uint8_t writeRAMCommand(uint8_t index) = 0;\n```\n> ************************************************************************\n",
    "lang": "c"
  },
  {
    "name": "setRAMAddress",
    "file": "[Adafruit_EPD.h](https://github.com/mongoose-os-libs/arduino-adafruit-epd/blob/master/include/Adafruit_EPD.h)",
    "doc": "\n```c\nvirtual void setRAMAddress(uint16_t x, uint16_t y) = 0;\n```\n> ************************************************************************\n",
    "lang": "c"
  },
  {
    "name": "powerUp",
    "file": "[Adafruit_EPD.h](https://github.com/mongoose-os-libs/arduino-adafruit-epd/blob/master/include/Adafruit_EPD.h)",
    "doc": "\n```c\nvirtual void powerUp(void) = 0;\n```\n> ************************************************************************\n",
    "lang": "c"
  },
  {
    "name": "update",
    "file": "[Adafruit_EPD.h](https://github.com/mongoose-os-libs/arduino-adafruit-epd/blob/master/include/Adafruit_EPD.h)",
    "doc": "\n```c\nvirtual void update(void) = 0;\n```\n> ************************************************************************\n",
    "lang": "c"
  },
  {
    "name": "powerDown",
    "file": "[Adafruit_EPD.h](https://github.com/mongoose-os-libs/arduino-adafruit-epd/blob/master/include/Adafruit_EPD.h)",
    "doc": "\n```c\nvirtual void powerDown(void) = 0;\n  void hardwareReset(void);\n```\n> ************************************************************************\n",
    "lang": "c"
  },
  {
    "name": "drawPixel",
    "file": "[Adafruit_GFX.h](https://github.com/mongoose-os-libs/arduino-adafruit-gfx/blob/master/include/Adafruit_GFX.h)",
    "doc": "\n```c\nvirtual void drawPixel(int16_t x, int16_t y, uint16_t color) = 0;\n```\n> Constructor\n> This MUST be defined by the subclass:\n",
    "lang": "c"
  },
  {
    "name": "startWrite",
    "file": "[Adafruit_GFX.h](https://github.com/mongoose-os-libs/arduino-adafruit-gfx/blob/master/include/Adafruit_GFX.h)",
    "doc": "\n```c\nvirtual void startWrite(void);\n  virtual void writePixel(int16_t x, int16_t y, uint16_t color);\n  virtual void writeFillRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color);\n  virtual void writeFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color);\n  virtual void writeFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color);\n  virtual void writeLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t color);\n  virtual void endWrite(void);\n```\n> TRANSACTION API / CORE DRAW API\n> These MAY be overridden by the subclass to provide device-specific\n> optimized code.  Otherwise 'generic' versions are used.\n",
    "lang": "c"
  },
  {
    "name": "setRotation",
    "file": "[Adafruit_GFX.h](https://github.com/mongoose-os-libs/arduino-adafruit-gfx/blob/master/include/Adafruit_GFX.h)",
    "doc": "\n```c\nvirtual void setRotation(uint8_t r);\n  virtual void invertDisplay(boolean i);\n```\n> CONTROL API\n> These MAY be overridden by the subclass to provide device-specific\n> optimized code.  Otherwise 'generic' versions are used.\n",
    "lang": "c"
  },
  {
    "name": "getCursorX",
    "file": "[Adafruit_GFX.h](https://github.com/mongoose-os-libs/arduino-adafruit-gfx/blob/master/include/Adafruit_GFX.h)",
    "doc": "\n```c\nint16_t getCursorX(void) const;\n  int16_t getCursorY(void) const;\n```\n> get current cursor position (get rotation safe maximum values, using: width() for x, height() for y)\n",
    "lang": "c"
  },
  {
    "name": "initButton",
    "file": "[Adafruit_GFX.h](https://github.com/mongoose-os-libs/arduino-adafruit-gfx/blob/master/include/Adafruit_GFX.h)",
    "doc": "\n```c\nvoid initButton(Adafruit_GFX *gfx, int16_t x, int16_t y,\n   uint16_t w, uint16_t h, uint16_t outline, uint16_t fill,\n   uint16_t textcolor, char *label, uint8_t textsize);\n  // New/alt initButton() uses upper-left corner & size\n  void initButtonUL(Adafruit_GFX *gfx, int16_t x1, int16_t y1,\n   uint16_t w, uint16_t h, uint16_t outline, uint16_t fill,\n   uint16_t textcolor, char *label, uint8_t textsize);\n  void drawButton(boolean inverted = false);\n  boolean contains(int16_t x, int16_t y);\n```\n> \"Classic\" initButton() uses center & size\n",
    "lang": "c"
  },
  {
    "name": "myHTU.begin()",
    "file": "[api_arduino_htu21df.js](https://github.com/mongoose-os-libs/arduino-adafruit-htu21df/blob/master/mjs_fs/api_arduino_htu21df.js)",
    "doc": "\n```javascript\nmyHTU.begin()\n```\nInitialize sensor and make it ready for use.\nReturn value: 1 if sensor is ready, 0 otherwise.\n",
    "lang": "js"
  },
  {
    "name": "myHTU.readTemperature()",
    "file": "[api_arduino_htu21df.js](https://github.com/mongoose-os-libs/arduino-adafruit-htu21df/blob/master/mjs_fs/api_arduino_htu21df.js)",
    "doc": "\n```javascript\nmyHTU.readTemperature()\n```\nRead the current temperature.\nReturn value: current temperature value in Celsius as a double.\n",
    "lang": "js"
  },
  {
    "name": "myHTU.readHumidity()",
    "file": "[api_arduino_htu21df.js](https://github.com/mongoose-os-libs/arduino-adafruit-htu21df/blob/master/mjs_fs/api_arduino_htu21df.js)",
    "doc": "\n```javascript\nmyHTU.readHumidity()\n```\nRead the current relative humidity as a percentage.\nReturn value: current humidity value as a double.\n",
    "lang": "js"
  },
  {
    "name": "myHTU.reset()",
    "file": "[api_arduino_htu21df.js](https://github.com/mongoose-os-libs/arduino-adafruit-htu21df/blob/master/mjs_fs/api_arduino_htu21df.js)",
    "doc": "\n```javascript\nmyHTU.reset()\n```\nReset the sensor - sends the sensor-specific command to reset.\nReturn value: none\n",
    "lang": "js"
  },
  {
    "name": "Adafruit_HTU21DF.create()",
    "file": "[api_arduino_htu21df.js](https://github.com/mongoose-os-libs/arduino-adafruit-htu21df/blob/master/mjs_fs/api_arduino_htu21df.js)",
    "doc": "\n```javascript\nAdafruit_HTU21DF.create()\n```\nCreate an Adafruit_HTU21DF instance on I2C bus (address = 0x40).\nReturn value: an object with the methods defined in _proto: {...} (above).\n",
    "lang": "js"
  },
  {
    "name": "Adafruit_PWMServoDriver.create()",
    "file": "[api_pwm_servo.js](https://github.com/mongoose-os-libs/arduino-adafruit-pwm-servo/blob/master/mjs_fs/api_pwm_servo.js)",
    "doc": "\n```javascript\nAdafruit_PWMServoDriver.create()\n```\nCreate an instance of PWM servo driver, which has the methods described\nbelow.\n\nExample:\n```javascript\nload(\"api_pwm_servo.js\");\nlet myServo = Adafruit_PWMServoDriver.create();\n```\n",
    "lang": "js"
  },
  {
    "name": "myServo.close()",
    "file": "[api_pwm_servo.js](https://github.com/mongoose-os-libs/arduino-adafruit-pwm-servo/blob/master/mjs_fs/api_pwm_servo.js)",
    "doc": "\n```javascript\nmyServo.close()\n```\nClose a servo instance; no other methods can be called on this instance\nafter calling `close()`.\nReturn value: none.\n",
    "lang": "js"
  },
  {
    "name": "myServo.begin()",
    "file": "[api_pwm_servo.js](https://github.com/mongoose-os-libs/arduino-adafruit-pwm-servo/blob/master/mjs_fs/api_pwm_servo.js)",
    "doc": "\n```javascript\nmyServo.begin()\n```\nReset onewire and servo state.\nReturn value: none.\n",
    "lang": "js"
  },
  {
    "name": "myServo.setPWMFreq(freq)",
    "file": "[api_pwm_servo.js](https://github.com/mongoose-os-libs/arduino-adafruit-pwm-servo/blob/master/mjs_fs/api_pwm_servo.js)",
    "doc": "\n```javascript\nmyServo.setPWMFreq(freq)\n```\nThis function can be used to adjust the PWM frequency (from 40 to 1000\nHz), which determines how many full 'pulses' per second are generated by\nthe IC. Stated differently, the frequency determines how 'long' each\npulse is in duration from start to finish, taking into account both the\nhigh and low segments of the pulse.\n\nFrequency is important in PWM, since setting the frequency too high with\na very small duty cycle can cause problems, since the 'rise time' of the\nsignal (the time it takes to go from 0V to VCC) may be longer than the\ntime the signal is active, and the PWM output will appear smoothed out\nand may not even reach VCC, potentially causing a number of problems.\n\nReturn value: none.\n\nExample:\n```javascript\nload(\"api_pwm_servo.js\");\nlet myServo = Adafruit_PWMServoDriver.create();\nmyServo.begin();\nmyServo.setPWMFreq(100);\n```\n",
    "lang": "js"
  },
  {
    "name": "myServo.setPWM(channel, on, off)",
    "file": "[api_pwm_servo.js](https://github.com/mongoose-os-libs/arduino-adafruit-pwm-servo/blob/master/mjs_fs/api_pwm_servo.js)",
    "doc": "\n```javascript\nmyServo.setPWM(channel, on, off)\n```\nThis function sets the start (`on`) and end (`off`) of the high segment of\nthe PWM pulse on a specific channel. You specify the 'tick' value\nbetween 0..4095 when the signal will turn on, and when it will turn of.\n`channel` (a number from `0` to `15`) indicates which of the 16 PWM\noutputs should be updated with the new values.\n\nReturn value: none.\n\nExample:\n```javascript\nload(\"api_pwm_servo.js\");\nlet myServo = Adafruit_PWMServoDriver.create();\nmyServo.begin();\n// Generate square wave at 100 Hz\nmyServo.setPWMFreq(100);\nmyServo.setPWM(0, 0, 2047);\n```\n",
    "lang": "js"
  },
  {
    "name": "myServo.setPin(channel, val, invert)",
    "file": "[api_pwm_servo.js](https://github.com/mongoose-os-libs/arduino-adafruit-pwm-servo/blob/master/mjs_fs/api_pwm_servo.js)",
    "doc": "\n```javascript\nmyServo.setPin(channel, val, invert)\n```\nThis is a wrapper for `myServo.setPWM()`, where `on` will always be 0,\nand `off` is the `val` given to this function. Additionally, `invert`\ncan be set to `true` to invert the output.\n\nReturn value: none.\n\nExample:\n```javascript\nload(\"api_pwm_servo.js\");\nlet myServo = Adafruit_PWMServoDriver.create();\nmyServo.begin();\n// Generate square wave at 100 Hz\nmyServo.setPWMFreq(100);\nmyServo.setPin(0, 2047, false);\n```\n",
    "lang": "js"
  },
  {
    "name": "Colors",
    "file": "[api_arduino_ssd1306.js](https://github.com/mongoose-os-libs/arduino-adafruit-ssd1306/blob/master/mjs_fs/api_arduino_ssd1306.js)",
    "doc": "\n```javascript\nColors\n```\n- `Adafruit_SSD1306.BLACK`\n- `Adafruit_SSD1306.WHITE`\n- `Adafruit_SSD1306.INVERSE`\n",
    "lang": "js"
  },
  {
    "name": "Adafruit_SSD1306.create_i2c(rst, res)",
    "file": "[api_arduino_ssd1306.js](https://github.com/mongoose-os-libs/arduino-adafruit-ssd1306/blob/master/mjs_fs/api_arduino_ssd1306.js)",
    "doc": "\n```javascript\nAdafruit_SSD1306.create_i2c(rst, res)\n```\nCreate an SSD1306 object for I2C. `rst` is a number of reset pin,\n`res` is the resolution, one of the:\n- `Adafruit_SSD1306.RES_96_16`\n- `Adafruit_SSD1306.RES_128_32`\n- `Adafruit_SSD1306.RES_128_64`\n\nReturn value: an object with methods described below.\nExample:\n```javascript\nAdafruit_SSD1306.create_i2c(12, Adafruit_SSD1306.RES_128_32);\n```\n",
    "lang": "js"
  },
  {
    "name": "Adafruit_SSD1306.create_spi(dc, rst, cs, res)",
    "file": "[api_arduino_ssd1306.js](https://github.com/mongoose-os-libs/arduino-adafruit-ssd1306/blob/master/mjs_fs/api_arduino_ssd1306.js)",
    "doc": "\n```javascript\nAdafruit_SSD1306.create_spi(dc, rst, cs, res)\n```\nCreate an SSD1306 object for SPI.\n`dc` is a number of data command pin, `rst` is a number of reset pin,\n`cs` is a number of chip select pin, `res` is the resolution, one of the:\n- `Adafruit_SSD1306.RES_96_16`\n- `Adafruit_SSD1306.RES_128_32`\n- `Adafruit_SSD1306.RES_128_64`\n\nReturn value: an object with methods described below.\nExample:\n```javascript\nAdafruit_SSD1306.create_spi(10, 12, 11, Adafruit_SSD1306.RES_128_32);\n```\n",
    "lang": "js"
  },
  {
    "name": "mySSD1306.close()",
    "file": "[api_arduino_ssd1306.js](https://github.com/mongoose-os-libs/arduino-adafruit-ssd1306/blob/master/mjs_fs/api_arduino_ssd1306.js)",
    "doc": "\n```javascript\nmySSD1306.close()\n```\nClose Adafruit_SSD1306 instance. Return value: none.\n",
    "lang": "js"
  },
  {
    "name": "mySSD1306.begin(vccst, i2caddr, reset)",
    "file": "[api_arduino_ssd1306.js](https://github.com/mongoose-os-libs/arduino-adafruit-ssd1306/blob/master/mjs_fs/api_arduino_ssd1306.js)",
    "doc": "\n```javascript\nmySSD1306.begin(vccst, i2caddr, reset)\n```\nInitialize the display. `vccst` is a VCC state, one of those:\n- `Adafruit_SSD1306.EXTERNALVCC`\n- `Adafruit_SSD1306.SWITCHCAPVCC`\n`i2caddr` is an I2C address (ignored if `create_spi` was used). `reset`\nis a boolean; if true, then the display controller will be reset.\nReturn value: none.\nExample:\n```javascript\nmySSD1306.begin(Adafruit_SSD1306.EXTERNALVCC, 0x42, true);\n```\n",
    "lang": "js"
  },
  {
    "name": "mySSD1306.ssd1306_command(cmd)",
    "file": "[api_arduino_ssd1306.js](https://github.com/mongoose-os-libs/arduino-adafruit-ssd1306/blob/master/mjs_fs/api_arduino_ssd1306.js)",
    "doc": "\n```javascript\nmySSD1306.ssd1306_command(cmd)\n```\nSend an arbitrary command `cmd`, which must be a number from 0 to 255.\nReturn value: none.\n",
    "lang": "js"
  },
  {
    "name": "mySSD1306.clearDisplay()",
    "file": "[api_arduino_ssd1306.js](https://github.com/mongoose-os-libs/arduino-adafruit-ssd1306/blob/master/mjs_fs/api_arduino_ssd1306.js)",
    "doc": "\n```javascript\nmySSD1306.clearDisplay()\n```\nClear display. Return value: none.\n",
    "lang": "js"
  },
  {
    "name": "mySSD1306.invertDisplay(i)",
    "file": "[api_arduino_ssd1306.js](https://github.com/mongoose-os-libs/arduino-adafruit-ssd1306/blob/master/mjs_fs/api_arduino_ssd1306.js)",
    "doc": "\n```javascript\nmySSD1306.invertDisplay(i)\n```\nSet invert mode: 0 - don't invert; 1 - invert. Return value: none.\n",
    "lang": "js"
  },
  {
    "name": "mySSD1306.display()",
    "file": "[api_arduino_ssd1306.js](https://github.com/mongoose-os-libs/arduino-adafruit-ssd1306/blob/master/mjs_fs/api_arduino_ssd1306.js)",
    "doc": "\n```javascript\nmySSD1306.display()\n```\nPut image data to the display. Return value: none.\n",
    "lang": "js"
  },
  {
    "name": "mySSD1306.startScrollRight()",
    "file": "[api_arduino_ssd1306.js](https://github.com/mongoose-os-libs/arduino-adafruit-ssd1306/blob/master/mjs_fs/api_arduino_ssd1306.js)",
    "doc": "\n```javascript\nmySSD1306.startScrollRight()\n```\nActivate a right handed scroll for rows from `start` to `stop`.\nReturn value: none.\n",
    "lang": "js"
  },
  {
    "name": "mySSD1306.startScrollLeft()",
    "file": "[api_arduino_ssd1306.js](https://github.com/mongoose-os-libs/arduino-adafruit-ssd1306/blob/master/mjs_fs/api_arduino_ssd1306.js)",
    "doc": "\n```javascript\nmySSD1306.startScrollLeft()\n```\nActivate a left handed scroll for rows from `start` to `stop`.\nReturn value: none.\n",
    "lang": "js"
  },
  {
    "name": "mySSD1306.startScrollDiagRight()",
    "file": "[api_arduino_ssd1306.js](https://github.com/mongoose-os-libs/arduino-adafruit-ssd1306/blob/master/mjs_fs/api_arduino_ssd1306.js)",
    "doc": "\n```javascript\nmySSD1306.startScrollDiagRight()\n```\nActivate a diagonal scroll for rows from `start` to `stop`.\nReturn value: none.\n",
    "lang": "js"
  },
  {
    "name": "mySSD1306.startScrollDiagLeft()",
    "file": "[api_arduino_ssd1306.js](https://github.com/mongoose-os-libs/arduino-adafruit-ssd1306/blob/master/mjs_fs/api_arduino_ssd1306.js)",
    "doc": "\n```javascript\nmySSD1306.startScrollDiagLeft()\n```\nActivate a diagonal scroll for rows from `start` to `stop`.\nReturn value: none.\n",
    "lang": "js"
  },
  {
    "name": "mySSD1306.stopScroll()",
    "file": "[api_arduino_ssd1306.js](https://github.com/mongoose-os-libs/arduino-adafruit-ssd1306/blob/master/mjs_fs/api_arduino_ssd1306.js)",
    "doc": "\n```javascript\nmySSD1306.stopScroll()\n```\nStop scrolling. Return value: none.\n",
    "lang": "js"
  },
  {
    "name": "mySSD1306.dim(dim)",
    "file": "[api_arduino_ssd1306.js](https://github.com/mongoose-os-libs/arduino-adafruit-ssd1306/blob/master/mjs_fs/api_arduino_ssd1306.js)",
    "doc": "\n```javascript\nmySSD1306.dim(dim)\n```\nSet dim mode:\n`dim` is 1: display is dimmed;\n`dim` is 0: display is normal.\nReturn value: none.\n",
    "lang": "js"
  },
  {
    "name": "mySSD1306.drawPixel(x, y, color)",
    "file": "[api_arduino_ssd1306.js](https://github.com/mongoose-os-libs/arduino-adafruit-ssd1306/blob/master/mjs_fs/api_arduino_ssd1306.js)",
    "doc": "\n```javascript\nmySSD1306.drawPixel(x, y, color)\n```\nSet a single pixel with coords `x`, `y` to have the given `color`. See\navailable colors above.\nReturn value: none.\n",
    "lang": "js"
  },
  {
    "name": "mySSD1306.drawFastVLine(x, y, h, color)",
    "file": "[api_arduino_ssd1306.js](https://github.com/mongoose-os-libs/arduino-adafruit-ssd1306/blob/master/mjs_fs/api_arduino_ssd1306.js)",
    "doc": "\n```javascript\nmySSD1306.drawFastVLine(x, y, h, color)\n```\nDraw a vertical line with height `h` starting from `x`, `y`, with color\n`color`. See available colors above.\nReturn value: none.\nExample:\n```javascript\nmySSD1306.drawFastVLine(10, 5, 15, Adafruit_SSD1306.WHITE);\n```\n",
    "lang": "js"
  },
  {
    "name": "mySSD1306.drawFastHLine(x, y, w, color)",
    "file": "[api_arduino_ssd1306.js](https://github.com/mongoose-os-libs/arduino-adafruit-ssd1306/blob/master/mjs_fs/api_arduino_ssd1306.js)",
    "doc": "\n```javascript\nmySSD1306.drawFastHLine(x, y, w, color)\n```\nDraw a horizontal line of width `w` starting from `x`, `y`, with color\n`color`. See available colors above.\nReturn value: none.\nExample:\n```javascript\nmySSD1306.drawFastHLine(10, 10, 20, Adafruit_SSD1306.WHITE);\n```\n",
    "lang": "js"
  },
  {
    "name": "mySSD1306.drawCircle(x, y, r, color)",
    "file": "[api_arduino_ssd1306.js](https://github.com/mongoose-os-libs/arduino-adafruit-ssd1306/blob/master/mjs_fs/api_arduino_ssd1306.js)",
    "doc": "\n```javascript\nmySSD1306.drawCircle(x, y, r, color)\n```\nDraw a circle with the radius `r`, centered at from `x`, `y`, with color\n`color`. See available colors above.\nReturn value: none.\nExample:\n```javascript\nmySSD1306.drawCircle(10, 10, 20, 10, 3, Adafruit_SSD1306.WHITE);\n```\n",
    "lang": "js"
  },
  {
    "name": "mySSD1306.fillCircle(x, y, r, color)",
    "file": "[api_arduino_ssd1306.js](https://github.com/mongoose-os-libs/arduino-adafruit-ssd1306/blob/master/mjs_fs/api_arduino_ssd1306.js)",
    "doc": "\n```javascript\nmySSD1306.fillCircle(x, y, r, color)\n```\nDraw a filled circle with the radius `r`, centered at from `x`, `y`,\nwith color `color`. See available colors above.\nReturn value: none.\nExample:\n```javascript\nmySSD1306.fillCircle(10, 10, 5, Adafruit_SSD1306.WHITE);\n```\n",
    "lang": "js"
  },
  {
    "name": "mySSD1306.drawTriangle(x0, y0, x1, y1, x2, y2, color)",
    "file": "[api_arduino_ssd1306.js](https://github.com/mongoose-os-libs/arduino-adafruit-ssd1306/blob/master/mjs_fs/api_arduino_ssd1306.js)",
    "doc": "\n```javascript\nmySSD1306.drawTriangle(x0, y0, x1, y1, x2, y2, color)\n```\nDraw a triangle at the given coordinates, with color `color`. See\navailable colors above.\nReturn value: none.\nExample:\n```javascript\nmySSD1306.drawTriangle(10, 0, 20, 20, 0, 20, Adafruit_SSD1306.WHITE);\n```\n",
    "lang": "js"
  },
  {
    "name": "mySSD1306.drawRoundRect(x0, y0, w, h, radius, color)",
    "file": "[api_arduino_ssd1306.js](https://github.com/mongoose-os-libs/arduino-adafruit-ssd1306/blob/master/mjs_fs/api_arduino_ssd1306.js)",
    "doc": "\n```javascript\nmySSD1306.drawRoundRect(x0, y0, w, h, radius, color)\n```\nDraw a rectangle with round corners; `x0`, `y0` are the coords of the\nleft-top corner, `w` is width, `h` is height, `radius` is the corners\nradius, with color `color`. See available colors above.\nReturn value: none.\nExample:\n```javascript\nmySSD1306.drawRoundRect(10, 10, 20, 10, 3, Adafruit_SSD1306.WHITE);\n```\n",
    "lang": "js"
  },
  {
    "name": "mySSD1306.drawRoundRect(x0, y0, w, h, radius, color)",
    "file": "[api_arduino_ssd1306.js](https://github.com/mongoose-os-libs/arduino-adafruit-ssd1306/blob/master/mjs_fs/api_arduino_ssd1306.js)",
    "doc": "\n```javascript\nmySSD1306.drawRoundRect(x0, y0, w, h, radius, color)\n```\nDraw a filled rectangle with round corners; `x0`, `y0` are the coords of\nthe left-top corner, `w` is width, `h` is height, `radius` is the\ncorners radius, with color `color`. See available colors above.\nReturn value: none.\nExample:\n```javascript\nmySSD1306.fillRoundRect(10, 10, 20, 10, 3, Adafruit_SSD1306.WHITE);\n```\n",
    "lang": "js"
  },
  {
    "name": "mySSD1306.drawChar(x, y, c, color, bg, size)",
    "file": "[api_arduino_ssd1306.js](https://github.com/mongoose-os-libs/arduino-adafruit-ssd1306/blob/master/mjs_fs/api_arduino_ssd1306.js)",
    "doc": "\n```javascript\nmySSD1306.drawChar(x, y, c, color, bg, size)\n```\nDraw a character `c` starting at the point `x`, `y`, with the color\n`color` (see available colors above). If `bg` is different from `color`,\nthen the background is filled with `bg`; otherwise bacground is left\nintact.\n\nThere is only one font (to save space) and it's meant to be 5x8 pixels,\nbut an optional `size` parameter which scales the font by this factor (e.g.\nsize=2 will render the text at 10x16 pixels per character).\nReturn value: none.\nExample:\n```javascript\nmySSD1306.drawChar(10, 10, 'a',\n                   Adafruit_SSD1306.WHITE, Adafruit_SSD1306.WHITE, 1);\n```\n",
    "lang": "js"
  },
  {
    "name": "mySSD1306.setCursor(x, y)",
    "file": "[api_arduino_ssd1306.js](https://github.com/mongoose-os-libs/arduino-adafruit-ssd1306/blob/master/mjs_fs/api_arduino_ssd1306.js)",
    "doc": "\n```javascript\nmySSD1306.setCursor(x, y)\n```\nSet text cursor for the following calls to `mySSD1306.write()`.\nSee example for `write()` below.\nReturn value: none.\n",
    "lang": "js"
  },
  {
    "name": "mySSD1306.setTextColor(color)",
    "file": "[api_arduino_ssd1306.js](https://github.com/mongoose-os-libs/arduino-adafruit-ssd1306/blob/master/mjs_fs/api_arduino_ssd1306.js)",
    "doc": "\n```javascript\nmySSD1306.setTextColor(color)\n```\nSet text color for the following calls to `mySSD1306.write()`. See\navailable colors above.\nSee example for `write()` below.\nReturn value: none.\n",
    "lang": "js"
  },
  {
    "name": "mySSD1306.setTextColorBg(color, bg)",
    "file": "[api_arduino_ssd1306.js](https://github.com/mongoose-os-libs/arduino-adafruit-ssd1306/blob/master/mjs_fs/api_arduino_ssd1306.js)",
    "doc": "\n```javascript\nmySSD1306.setTextColorBg(color, bg)\n```\nSet text color and background color for the following calls to\n`mySSD1306.write()`. If `bg` is equal to the `color`, then the\nbackground will be left intact while drawing characters.\nSee example for `write()` below.\nReturn value: none.\n",
    "lang": "js"
  },
  {
    "name": "mySSD1306.setTextSize(size)",
    "file": "[api_arduino_ssd1306.js](https://github.com/mongoose-os-libs/arduino-adafruit-ssd1306/blob/master/mjs_fs/api_arduino_ssd1306.js)",
    "doc": "\n```javascript\nmySSD1306.setTextSize(size)\n```\nSet text color for the following calls to `mySSD1306.write()`. There is\nonly one font (to save space) and it's meant to be 5x8 pixels, but an\noptional `size` parameter which scales the font by this factor (e.g.\nsize=2 will render the text at 10x16 pixels per character).\nSee example for `write()` below.\nReturn value: none.\n",
    "lang": "js"
  },
  {
    "name": "mySSD1306.setTextWrap(wrap)",
    "file": "[api_arduino_ssd1306.js](https://github.com/mongoose-os-libs/arduino-adafruit-ssd1306/blob/master/mjs_fs/api_arduino_ssd1306.js)",
    "doc": "\n```javascript\nmySSD1306.setTextWrap(wrap)\n```\nSet text wrap mode (true or false) for the following calls to\n`mySSD1306.write()`.\nSee example for `write()` below.\nReturn value: none.\n",
    "lang": "js"
  },
  {
    "name": "mySSD1306.write(str)",
    "file": "[api_arduino_ssd1306.js](https://github.com/mongoose-os-libs/arduino-adafruit-ssd1306/blob/master/mjs_fs/api_arduino_ssd1306.js)",
    "doc": "\n```javascript\nmySSD1306.write(str)\n```\nWrite given string `str` using the parameters set before (`setCursor()`,\n`setTextColor()`, `setTextColorBg()`, `setTextSize()`, `setTextWrap()`)\nReturn value: 1.\nExample:\n```javascript\nmySSD1306.setCursor(10, 10);\nmySSD1306.setTextColor(Adafruit_SSD1306.WHITE);\nmySSD1306.setTextSize(2);\nmySSD1306.setTextWrap(true);\nmySSD1306.write(\"Hello world!\");\n```\n",
    "lang": "js"
  },
  {
    "name": "mySSD1306.height()",
    "file": "[api_arduino_ssd1306.js](https://github.com/mongoose-os-libs/arduino-adafruit-ssd1306/blob/master/mjs_fs/api_arduino_ssd1306.js)",
    "doc": "\n```javascript\nmySSD1306.height()\n```\nReturn display height in pixels.\n",
    "lang": "js"
  },
  {
    "name": "mySSD1306.width()",
    "file": "[api_arduino_ssd1306.js](https://github.com/mongoose-os-libs/arduino-adafruit-ssd1306/blob/master/mjs_fs/api_arduino_ssd1306.js)",
    "doc": "\n```javascript\nmySSD1306.width()\n```\nReturn display width in pixels.\n",
    "lang": "js"
  },
  {
    "name": "mySSD1306.setRotation(rot)",
    "file": "[api_arduino_ssd1306.js](https://github.com/mongoose-os-libs/arduino-adafruit-ssd1306/blob/master/mjs_fs/api_arduino_ssd1306.js)",
    "doc": "\n```javascript\nmySSD1306.setRotation(rot)\n```\nSet display rotation:\n- 0: no rotation\n- 1: rotated at 90 degrees\n- 2: rotated at 180 degrees\n- 3: rotated at 270 degrees\n",
    "lang": "js"
  },
  {
    "name": "mySSD1306.getRotation()",
    "file": "[api_arduino_ssd1306.js](https://github.com/mongoose-os-libs/arduino-adafruit-ssd1306/blob/master/mjs_fs/api_arduino_ssd1306.js)",
    "doc": "\n```javascript\nmySSD1306.getRotation()\n```\nReturn rotation previously set with `setRotation()`\n",
    "lang": "js"
  },
  {
    "name": "mySSD1306.getCursorX()",
    "file": "[api_arduino_ssd1306.js](https://github.com/mongoose-os-libs/arduino-adafruit-ssd1306/blob/master/mjs_fs/api_arduino_ssd1306.js)",
    "doc": "\n```javascript\nmySSD1306.getCursorX()\n```\nReturn cursor X coordinate, previously set with `setCursor()`.\n",
    "lang": "js"
  },
  {
    "name": "mySSD1306.getCursorY()",
    "file": "[api_arduino_ssd1306.js](https://github.com/mongoose-os-libs/arduino-adafruit-ssd1306/blob/master/mjs_fs/api_arduino_ssd1306.js)",
    "doc": "\n```javascript\nmySSD1306.getCursorY()\n```\nReturn cursor Y coordinate, previously set with `setCursor()`.\n",
    "lang": "js"
  },
  {
    "name": "getLuminosity( p )",
    "file": "[api_arduino_tsl2561.js](https://github.com/mongoose-os-libs/arduino-adafruit-tsl2561/blob/master/mjs_fs/api_arduino_tsl2561.js)",
    "doc": "\n```javascript\ngetLuminosity( p )\n```\n### ** Adafruit_TSL2561.TSL2561_VISIBLE **\nget visible luminosity:  channel 0 - channel 1\n",
    "lang": "js"
  },
  {
    "name": "myTSL.begin()",
    "file": "[api_arduino_tsl2561.js](https://github.com/mongoose-os-libs/arduino-adafruit-tsl2561/blob/master/mjs_fs/api_arduino_tsl2561.js)",
    "doc": "\n```javascript\nmyTSL.begin()\n```\nInitialize sensor and make it ready for use.\nReturn value: 1 if sensor is ready, 0 otherwise.\n",
    "lang": "js"
  },
  {
    "name": "myTSL.getLuminosity( lumo )",
    "file": "[api_arduino_tsl2561.js](https://github.com/mongoose-os-libs/arduino-adafruit-tsl2561/blob/master/mjs_fs/api_arduino_tsl2561.js)",
    "doc": "\n```javascript\nmyTSL.getLuminosity( lumo )\n```\nReturn the current luminosity for either channel or both.\nSet `lumo` parameter to:\n* `Adafruit_TSL2561.TSL2561_INFRARED` for channel 1 (infrared) contribution to luminosity\n* `Adafruit_TSL2561.TSL2561_FULLSPECTRUM` for channel 1 and channel 0 combined as luminosity\n* `Adafruit_TSL2561.TSL2561_VISIBLE` for channel 0 (visible) contribution to luminosity\nReturn value: current humidity value as a double.\n",
    "lang": "js"
  },
  {
    "name": "myTSL.getVisible( )",
    "file": "[api_arduino_tsl2561.js](https://github.com/mongoose-os-libs/arduino-adafruit-tsl2561/blob/master/mjs_fs/api_arduino_tsl2561.js)",
    "doc": "\n```javascript\nmyTSL.getVisible( )\n```\nConvenience function equivalent to calling `myTSL.getLuminosity( Adafruit_TSL2561.TSL2561_VISIBLE )`.\n",
    "lang": "js"
  },
  {
    "name": "myTSL.getInfrared( )",
    "file": "[api_arduino_tsl2561.js](https://github.com/mongoose-os-libs/arduino-adafruit-tsl2561/blob/master/mjs_fs/api_arduino_tsl2561.js)",
    "doc": "\n```javascript\nmyTSL.getInfrared( )\n```\nConvenience function equivalent to calling `myTSL.getLuminosity( Adafruit_TSL2561.TSL2561_INFRARED )`.\n",
    "lang": "js"
  },
  {
    "name": "myTSL.getFullSpectrum( )",
    "file": "[api_arduino_tsl2561.js](https://github.com/mongoose-os-libs/arduino-adafruit-tsl2561/blob/master/mjs_fs/api_arduino_tsl2561.js)",
    "doc": "\n```javascript\nmyTSL.getFullSpectrum( )\n```\nConvenience function equivalent to calling `myTSL.getLuminosity( Adafruit_TSL2561.TSL2561_FULLSPECTRUM )`.\nReturn value:\n",
    "lang": "js"
  },
  {
    "name": "myTSL.getFullLuminosity( )",
    "file": "[api_arduino_tsl2561.js](https://github.com/mongoose-os-libs/arduino-adafruit-tsl2561/blob/master/mjs_fs/api_arduino_tsl2561.js)",
    "doc": "\n```javascript\nmyTSL.getFullLuminosity( )\n```\nReturn value:  32-bit `unsigned int` with the 16 high-bits containing channel 1 (infrared) and the 16 low-bits\ncontaining channel 0 (visible).\n",
    "lang": "js"
  },
  {
    "name": "myTSL.setIntegrationTime( t )",
    "file": "[api_arduino_tsl2561.js](https://github.com/mongoose-os-libs/arduino-adafruit-tsl2561/blob/master/mjs_fs/api_arduino_tsl2561.js)",
    "doc": "\n```javascript\nmyTSL.setIntegrationTime( t )\n```\nSet the sampling (integration) time of the sensor using the value of parameter `t`.\nAllowed values for `t` and their meanings are:\n* `Adafruit_TSL2561.TSL2561_INTEGRATIONTIME_13MS` 13.7ms - shortest integration time (bright light)\n* `Adafruit_TSL2561.TSL2561_INTEGRATIONTIME_101MS` 101ms  - medium integration time (medium light)\n* `Adafruit_TSL2561.TSL2561_INTEGRATIONTIME_402MS` 402ms  - longest integration time (dim light)\n",
    "lang": "js"
  },
  {
    "name": "myTSL.setGain( g )",
    "file": "[api_arduino_tsl2561.js](https://github.com/mongoose-os-libs/arduino-adafruit-tsl2561/blob/master/mjs_fs/api_arduino_tsl2561.js)",
    "doc": "\n```javascript\nmyTSL.setGain( g )\n```\nSet the gain of the sensor using the value of parameter `g`.\nAllowed values for `g` and their meanings are:\n* `Adafruit_TSL2561.TSL2561_GAIN_0X` No gain  - set no gain (for bright situations)\n* `Adafruit_TSL2561.TSL2561_GAIN_16X` 16x gain - set 16x gain (for dim situations)\n",
    "lang": "js"
  },
  {
    "name": "myTSL.calculateLux( ch0, ch1 )",
    "file": "[api_arduino_tsl2561.js](https://github.com/mongoose-os-libs/arduino-adafruit-tsl2561/blob/master/mjs_fs/api_arduino_tsl2561.js)",
    "doc": "\n```javascript\nmyTSL.calculateLux( ch0, ch1 )\n```\nUses the formula supplied in the sensor datasheet to calculate Lux for the supplied values of\nchannel 0 (ch0) and channel 1 (ch1).\nReturn value:  the calculated Lux\n",
    "lang": "js"
  },
  {
    "name": "Adafruit_TSL2561.create( addr )",
    "file": "[api_arduino_tsl2561.js](https://github.com/mongoose-os-libs/arduino-adafruit-tsl2561/blob/master/mjs_fs/api_arduino_tsl2561.js)",
    "doc": "\n```javascript\nAdafruit_TSL2561.create( addr )\n```\nCreate an Adafruit_TSL2561 instance on I2C bus.  Supported i2c addresses are:\n* `Adafruit_TSL2561.TSL2561_ADDR_LOW` (0x29)\n* `Adafruit_TSL2561.TSL2561_ADDR_FLOAT` (0x39 - default if addr not specified).\n* `Adafruit_TSL2561.TSL2561_ADDR_HIGH` (0x49)\nReturn value: an object representing the TSL2561 sensor with the methods defined in _proto: {...} (above).\n",
    "lang": "js"
  },
  {
    "name": "pinMode",
    "file": "[Arduino.h](https://github.com/mongoose-os-libs/arduino-compat/blob/master/include/Arduino.h)",
    "doc": "\n```c\nvoid pinMode(uint8_t pin, uint8_t mode);\nvoid digitalWrite(uint8_t pin, uint8_t val);\nint digitalRead(uint8_t pin);\n#ifdef TODO\nint analogRead(uint8_t pin);\nvoid analogReference(uint8_t mode);\nvoid analogWrite(uint8_t pin, int val);\nvoid analogWriteFreq(uint32_t freq);\nvoid analogWriteRange(uint32_t range);\n#endif\n```\n> int atexit(void (*func)()) __attribute__((weak));\n",
    "lang": "c"
  },
  {
    "name": "begin",
    "file": "[DallasTemperature.h](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/include/DallasTemperature.h)",
    "doc": "\n```c\nvoid begin(void);\n```\n> initialise bus\n",
    "lang": "c"
  },
  {
    "name": "getDeviceCount",
    "file": "[DallasTemperature.h](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/include/DallasTemperature.h)",
    "doc": "\n```c\nuint8_t getDeviceCount(void);\n```\n> returns the number of devices found on the bus\n",
    "lang": "c"
  },
  {
    "name": "validAddress",
    "file": "[DallasTemperature.h](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/include/DallasTemperature.h)",
    "doc": "\n```c\nbool validAddress(const uint8_t*);\n```\n> returns true if address is valid\n",
    "lang": "c"
  },
  {
    "name": "validFamily",
    "file": "[DallasTemperature.h](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/include/DallasTemperature.h)",
    "doc": "\n```c\nbool validFamily(const uint8_t* deviceAddress);\n```\n> returns true if address is of the family of sensors the lib supports.\n",
    "lang": "c"
  },
  {
    "name": "getAddress",
    "file": "[DallasTemperature.h](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/include/DallasTemperature.h)",
    "doc": "\n```c\nbool getAddress(uint8_t*, uint8_t);\n```\n> finds an address at a given index on the bus\n",
    "lang": "c"
  },
  {
    "name": "isConnected",
    "file": "[DallasTemperature.h](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/include/DallasTemperature.h)",
    "doc": "\n```c\nbool isConnected(const uint8_t*);\n```\n> attempt to determine if the device at the given address is connected to the bus\n",
    "lang": "c"
  },
  {
    "name": "isConnected",
    "file": "[DallasTemperature.h](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/include/DallasTemperature.h)",
    "doc": "\n```c\nbool isConnected(const uint8_t*, uint8_t*);\n```\n> attempt to determine if the device at the given address is connected to the bus\n> also allows for updating the read scratchpad\n",
    "lang": "c"
  },
  {
    "name": "readScratchPad",
    "file": "[DallasTemperature.h](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/include/DallasTemperature.h)",
    "doc": "\n```c\nbool readScratchPad(const uint8_t*, uint8_t*);\n```\n> read device's scratchpad\n",
    "lang": "c"
  },
  {
    "name": "writeScratchPad",
    "file": "[DallasTemperature.h](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/include/DallasTemperature.h)",
    "doc": "\n```c\nvoid writeScratchPad(const uint8_t*, const uint8_t*);\n```\n> write device's scratchpad\n",
    "lang": "c"
  },
  {
    "name": "readPowerSupply",
    "file": "[DallasTemperature.h](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/include/DallasTemperature.h)",
    "doc": "\n```c\nbool readPowerSupply(const uint8_t*);\n```\n> read device's power requirements\n",
    "lang": "c"
  },
  {
    "name": "getResolution",
    "file": "[DallasTemperature.h](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/include/DallasTemperature.h)",
    "doc": "\n```c\nuint8_t getResolution();\n```\n> get global resolution\n",
    "lang": "c"
  },
  {
    "name": "setResolution",
    "file": "[DallasTemperature.h](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/include/DallasTemperature.h)",
    "doc": "\n```c\nvoid setResolution(uint8_t);\n```\n> set global resolution to 9, 10, 11, or 12 bits\n",
    "lang": "c"
  },
  {
    "name": "getResolution",
    "file": "[DallasTemperature.h](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/include/DallasTemperature.h)",
    "doc": "\n```c\nuint8_t getResolution(const uint8_t*);\n```\n> returns the device resolution: 9, 10, 11, or 12 bits\n",
    "lang": "c"
  },
  {
    "name": "setResolution",
    "file": "[DallasTemperature.h](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/include/DallasTemperature.h)",
    "doc": "\n```c\nbool setResolution(const uint8_t*, uint8_t, bool skipGlobalBitResolutionCalculation = false);\n```\n> set resolution of a device to 9, 10, 11, or 12 bits\n",
    "lang": "c"
  },
  {
    "name": "setWaitForConversion",
    "file": "[DallasTemperature.h](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/include/DallasTemperature.h)",
    "doc": "\n```c\nvoid setWaitForConversion(bool);\n    bool getWaitForConversion(void);\n```\n> sets/gets the waitForConversion flag\n",
    "lang": "c"
  },
  {
    "name": "setCheckForConversion",
    "file": "[DallasTemperature.h](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/include/DallasTemperature.h)",
    "doc": "\n```c\nvoid setCheckForConversion(bool);\n    bool getCheckForConversion(void);\n```\n> sets/gets the checkForConversion flag\n",
    "lang": "c"
  },
  {
    "name": "requestTemperatures",
    "file": "[DallasTemperature.h](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/include/DallasTemperature.h)",
    "doc": "\n```c\nvoid requestTemperatures(void);\n```\n> sends command for all devices on the bus to perform a temperature conversion\n",
    "lang": "c"
  },
  {
    "name": "requestTemperaturesByAddress",
    "file": "[DallasTemperature.h](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/include/DallasTemperature.h)",
    "doc": "\n```c\nbool requestTemperaturesByAddress(const uint8_t*);\n```\n> sends command for one device to perform a temperature conversion by address\n",
    "lang": "c"
  },
  {
    "name": "requestTemperaturesByIndex",
    "file": "[DallasTemperature.h](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/include/DallasTemperature.h)",
    "doc": "\n```c\nbool requestTemperaturesByIndex(uint8_t);\n```\n> sends command for one device to perform a temperature conversion by index\n",
    "lang": "c"
  },
  {
    "name": "getTemp",
    "file": "[DallasTemperature.h](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/include/DallasTemperature.h)",
    "doc": "\n```c\nint16_t getTemp(const uint8_t*);\n```\n> returns temperature raw value (12 bit integer of 1/128 degrees C)\n",
    "lang": "c"
  },
  {
    "name": "getTempC",
    "file": "[DallasTemperature.h](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/include/DallasTemperature.h)",
    "doc": "\n```c\nfloat getTempC(const uint8_t*);\n```\n> returns temperature in degrees C\n",
    "lang": "c"
  },
  {
    "name": "getTempF",
    "file": "[DallasTemperature.h](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/include/DallasTemperature.h)",
    "doc": "\n```c\nfloat getTempF(const uint8_t*);\n```\n> returns temperature in degrees F\n",
    "lang": "c"
  },
  {
    "name": "getTempCByIndex",
    "file": "[DallasTemperature.h](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/include/DallasTemperature.h)",
    "doc": "\n```c\nfloat getTempCByIndex(uint8_t);\n```\n> Get temperature for device index (slow)\n",
    "lang": "c"
  },
  {
    "name": "getTempFByIndex",
    "file": "[DallasTemperature.h](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/include/DallasTemperature.h)",
    "doc": "\n```c\nfloat getTempFByIndex(uint8_t);\n```\n> Get temperature for device index (slow)\n",
    "lang": "c"
  },
  {
    "name": "isParasitePowerMode",
    "file": "[DallasTemperature.h](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/include/DallasTemperature.h)",
    "doc": "\n```c\nbool isParasitePowerMode(void);\n```\n> returns true if the bus requires parasite power\n",
    "lang": "c"
  },
  {
    "name": "isConversionComplete",
    "file": "[DallasTemperature.h](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/include/DallasTemperature.h)",
    "doc": "\n```c\nbool isConversionComplete(void);\n```\n> Is a conversion complete on the wire?\n",
    "lang": "c"
  },
  {
    "name": "setHighAlarmTemp",
    "file": "[DallasTemperature.h](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/include/DallasTemperature.h)",
    "doc": "\n```c\nvoid setHighAlarmTemp(const uint8_t*, char);\n```\n> sets the high alarm temperature for a device\n> accepts a char.  valid range is -55C - 125C\n",
    "lang": "c"
  },
  {
    "name": "setLowAlarmTemp",
    "file": "[DallasTemperature.h](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/include/DallasTemperature.h)",
    "doc": "\n```c\nvoid setLowAlarmTemp(const uint8_t*, char);\n```\n> sets the low alarm temperature for a device\n> accepts a char.  valid range is -55C - 125C\n",
    "lang": "c"
  },
  {
    "name": "getHighAlarmTemp",
    "file": "[DallasTemperature.h](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/include/DallasTemperature.h)",
    "doc": "\n```c\nchar getHighAlarmTemp(const uint8_t*);\n```\n> returns a signed char with the current high alarm temperature for a device\n> in the range -55C - 125C\n",
    "lang": "c"
  },
  {
    "name": "getLowAlarmTemp",
    "file": "[DallasTemperature.h](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/include/DallasTemperature.h)",
    "doc": "\n```c\nchar getLowAlarmTemp(const uint8_t*);\n```\n> returns a signed char with the current low alarm temperature for a device\n> in the range -55C - 125C\n",
    "lang": "c"
  },
  {
    "name": "resetAlarmSearch",
    "file": "[DallasTemperature.h](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/include/DallasTemperature.h)",
    "doc": "\n```c\nvoid resetAlarmSearch(void);\n```\n> resets internal variables used for the alarm search\n",
    "lang": "c"
  },
  {
    "name": "alarmSearch",
    "file": "[DallasTemperature.h](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/include/DallasTemperature.h)",
    "doc": "\n```c\nbool alarmSearch(uint8_t*);\n```\n> search the wire for devices with active alarms\n",
    "lang": "c"
  },
  {
    "name": "hasAlarm",
    "file": "[DallasTemperature.h](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/include/DallasTemperature.h)",
    "doc": "\n```c\nbool hasAlarm(const uint8_t*);\n```\n> returns true if ia specific device has an alarm\n",
    "lang": "c"
  },
  {
    "name": "hasAlarm",
    "file": "[DallasTemperature.h](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/include/DallasTemperature.h)",
    "doc": "\n```c\nbool hasAlarm(void);\n```\n> returns true if any device is reporting an alarm on the bus\n",
    "lang": "c"
  },
  {
    "name": "processAlarms",
    "file": "[DallasTemperature.h](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/include/DallasTemperature.h)",
    "doc": "\n```c\nvoid processAlarms(void);\n```\n> runs the alarm handler for all devices returned by alarmSearch()\n",
    "lang": "c"
  },
  {
    "name": "setAlarmHandler",
    "file": "[DallasTemperature.h](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/include/DallasTemperature.h)",
    "doc": "\n```c\nvoid setAlarmHandler(const AlarmHandler *);\n```\n> sets the alarm handler\n",
    "lang": "c"
  },
  {
    "name": "defaultAlarmHandler",
    "file": "[DallasTemperature.h](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/include/DallasTemperature.h)",
    "doc": "\n```c\nstatic void defaultAlarmHandler(const uint8_t*);\n```\n> The default alarm handler\n",
    "lang": "c"
  },
  {
    "name": "setUserData",
    "file": "[DallasTemperature.h](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/include/DallasTemperature.h)",
    "doc": "\n```c\nvoid setUserData(const uint8_t*, int16_t );\n    void setUserDataByIndex(uint8_t, int16_t );\n    int16_t getUserData(const uint8_t* );\n    int16_t getUserDataByIndex(uint8_t );\n```\n> if no alarm handler is used the two bytes can be used as user data\n> example of such usage is an ID.\n> note if device is not connected it will fail writing the data.\n> note if address cannot be found no error will be reported.\n> in short use carefully\n",
    "lang": "c"
  },
  {
    "name": "toFahrenheit",
    "file": "[DallasTemperature.h](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/include/DallasTemperature.h)",
    "doc": "\n```c\nstatic float toFahrenheit(float);\n```\n> convert from Celsius to Fahrenheit\n",
    "lang": "c"
  },
  {
    "name": "toCelsius",
    "file": "[DallasTemperature.h](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/include/DallasTemperature.h)",
    "doc": "\n```c\nstatic float toCelsius(float);\n```\n> convert from Fahrenheit to Celsius\n",
    "lang": "c"
  },
  {
    "name": "rawToCelsius",
    "file": "[DallasTemperature.h](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/include/DallasTemperature.h)",
    "doc": "\n```c\nstatic float rawToCelsius(int16_t);\n```\n> convert from raw to Celsius\n",
    "lang": "c"
  },
  {
    "name": "rawToFahrenheit",
    "file": "[DallasTemperature.h](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/include/DallasTemperature.h)",
    "doc": "\n```c\nstatic float rawToFahrenheit(int16_t);\n```\n> convert from raw to Fahrenheit\n",
    "lang": "c"
  },
  {
    "name": "delete",
    "file": "[DallasTemperature.h](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/include/DallasTemperature.h)",
    "doc": "\n```c\nvoid operator delete(void*);\n```\n> delete memory reference\n",
    "lang": "c"
  },
  {
    "name": "calculateTemperature",
    "file": "[DallasTemperature.h](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/include/DallasTemperature.h)",
    "doc": "\n```c\nint16_t calculateTemperature(const uint8_t*, uint8_t*);\n```\n> reads scratchpad and returns the raw temperature\n",
    "lang": "c"
  },
  {
    "name": "DallasTemperature.create(ow)",
    "file": "[api_arduino_dallas_temp.js](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/mjs_fs/api_arduino_dallas_temp.js)",
    "doc": "\n```javascript\nDallasTemperature.create(ow)\n```\nCreate and return an instance of the dallas temperature: an object with\nmethods described below. `ow` is an OneWire instance.\n\nExample:\n```javascript\nlet ow = OneWire(12 /* onewire pin number */);\nlet myDT = DallasTemperature.create(ow);\n```\n",
    "lang": "js"
  },
  {
    "name": "myDT.close()",
    "file": "[api_arduino_dallas_temp.js](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/mjs_fs/api_arduino_dallas_temp.js)",
    "doc": "\n```javascript\nmyDT.close()\n```\nClose DallasTemperature handle. Return value: none.\n",
    "lang": "js"
  },
  {
    "name": "myDT.begin()",
    "file": "[api_arduino_dallas_temp.js](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/mjs_fs/api_arduino_dallas_temp.js)",
    "doc": "\n```javascript\nmyDT.begin()\n```\nInitialise the sensor. Return value: none.\n",
    "lang": "js"
  },
  {
    "name": "myDT.getDeviceCount()",
    "file": "[api_arduino_dallas_temp.js](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/mjs_fs/api_arduino_dallas_temp.js)",
    "doc": "\n```javascript\nmyDT.getDeviceCount()\n```\nReturn the number of devices found on the bus.\nIf an operaiton is failed, 0 is returned.\n",
    "lang": "js"
  },
  {
    "name": "myDT.validAddress(addr)",
    "file": "[api_arduino_dallas_temp.js](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/mjs_fs/api_arduino_dallas_temp.js)",
    "doc": "\n```javascript\nmyDT.validAddress(addr)\n```\nCheck if given onewire `addr` (8-byte string) is valid; returns 1 if it\nis, or 0 otherwise.\n",
    "lang": "js"
  },
  {
    "name": "myDT.validFamily(addr)",
    "file": "[api_arduino_dallas_temp.js](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/mjs_fs/api_arduino_dallas_temp.js)",
    "doc": "\n```javascript\nmyDT.validFamily(addr)\n```\nReturn 1 if onewire address `addr` (8-byte string) is of the family of\nsensors the lib supports.  Return always 0 if an operaiton failed.\n",
    "lang": "js"
  },
  {
    "name": "myDT.getAddress(addr, idx)",
    "file": "[api_arduino_dallas_temp.js](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/mjs_fs/api_arduino_dallas_temp.js)",
    "doc": "\n```javascript\nmyDT.getAddress(addr, idx)\n```\nFind an onewire address at a given index `idx` on the bus. Resulting\naddress is written into the provided string buffer `addr`, which should\nbe 8 bytes lont.\nReturn value: 1 in case of success, 0 otherwise.\nExample:\n```javascript\nload(\"api_sys.js\");\nload(\"api_arduino_dallas_temp.js\");\n\nlet addr = Sys._sbuf(8);\nlet res = myDT.getAddress(addr, 0);\nif (res === 1) {\n  print(\"found:\", addr);\n} else {\n  print(\"not found\");\n}\n```\n",
    "lang": "js"
  },
  {
    "name": "myDT.isConnected(addr)",
    "file": "[api_arduino_dallas_temp.js](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/mjs_fs/api_arduino_dallas_temp.js)",
    "doc": "\n```javascript\nmyDT.isConnected(addr)\n```\nDetermine if the device at the given onewire address (8-byte string) is\nconnected to the bus.\nReturn value: 1 if device is connected, 0 otherwise.\n",
    "lang": "js"
  },
  {
    "name": "myDT.isConnectedWithScratchPad(addr, sp)",
    "file": "[api_arduino_dallas_temp.js](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/mjs_fs/api_arduino_dallas_temp.js)",
    "doc": "\n```javascript\nmyDT.isConnectedWithScratchPad(addr, sp)\n```\nDetermine if the device at the given onewire address (8-byte string) is\nconnected to the bus, and if so, read the scratch pad to the provided\nbuffer (9-byte string).\nReturn value: 1 if device is connected (and a scratchpad is read), 0\notherwise.\nExample:\n```javascript\nload(\"api_sys.js\");\nload(\"api_arduino_dallas_temp.js\");\n\nlet sp = Sys._sbuf(9);\nlet res = myDT.isConnectedWithScratchPad(\"\\x28\\xff\\x2b\\x45\\x4c\\x04\\x00\\x10\", sp);\nif (res === 1) {\n  print(\"connected, scratchpad:\", sp);\n} else {\n  print(\"not connected\");\n}\n```\n",
    "lang": "js"
  },
  {
    "name": "myDT.readScratchPad(addr, sp)",
    "file": "[api_arduino_dallas_temp.js](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/mjs_fs/api_arduino_dallas_temp.js)",
    "doc": "\n```javascript\nmyDT.readScratchPad(addr, sp)\n```\nRead device's scratchpad.\n`sp` is a string buffer (minimum 9 bytes length) to read scratchpad\ninto.\nReturn 1 in case of success, 0 otherwise.\nExample:\n```javascript\nload(\"api_sys.js\");\nload(\"api_arduino_dallas_temp.js\");\n\nlet sp = Sys._sbuf(9);\nlet res = myDT.readScratchPad(\"\\x28\\xff\\x2b\\x45\\x4c\\x04\\x00\\x10\", sp);\nif (res === 1) {\n  print(\"scratchpad:\", sp);\n} else {\n  print(\"failed to read scratchpad\");\n}\n```\n",
    "lang": "js"
  },
  {
    "name": "myDT.writeScratchPad(addr, sp)",
    "file": "[api_arduino_dallas_temp.js](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/mjs_fs/api_arduino_dallas_temp.js)",
    "doc": "\n```javascript\nmyDT.writeScratchPad(addr, sp)\n```\nWrite device's scratchpad `sp` (which should be a 9-byte string) by\nthe provided onewire address `addr` (a 8-byte string).\nReturn value: none.\n",
    "lang": "js"
  },
  {
    "name": "myDT.readPowerSupply()",
    "file": "[api_arduino_dallas_temp.js](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/mjs_fs/api_arduino_dallas_temp.js)",
    "doc": "\n```javascript\nmyDT.readPowerSupply()\n```\nRead device's power requirements.\nReturn 1 if device needs parasite power.\nReturn always 0 if an operaiton failed.\n",
    "lang": "js"
  },
  {
    "name": "myDT.getGlobalResolution()",
    "file": "[api_arduino_dallas_temp.js](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/mjs_fs/api_arduino_dallas_temp.js)",
    "doc": "\n```javascript\nmyDT.getGlobalResolution()\n```\nGet global resolution in bits. Return value: 9, 10, 11 or 12.\nIn case of a failure, returns 0.\n",
    "lang": "js"
  },
  {
    "name": "myDT.setGlobalResolution(res)",
    "file": "[api_arduino_dallas_temp.js](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/mjs_fs/api_arduino_dallas_temp.js)",
    "doc": "\n```javascript\nmyDT.setGlobalResolution(res)\n```\nSet global resolution `res` in bits, which can be either 9, 10, 11, or\n12. If given resolution is out of range, 9 bits is used.\nReturn value: none.\n",
    "lang": "js"
  },
  {
    "name": "myDT.getResolution(addr)",
    "file": "[api_arduino_dallas_temp.js](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/mjs_fs/api_arduino_dallas_temp.js)",
    "doc": "\n```javascript\nmyDT.getResolution(addr)\n```\nGet device's resolution in bits. Return value: 9, 10, 11 or 12.\nIn case of a failure, returns 0.\n",
    "lang": "js"
  },
  {
    "name": "myDT.setResolution(addr, res, skip)",
    "file": "[api_arduino_dallas_temp.js](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/mjs_fs/api_arduino_dallas_temp.js)",
    "doc": "\n```javascript\nmyDT.setResolution(addr, res, skip)\n```\nSet resolution of a device with onewire address `addr` to 9, 10, 11, or\n12 bits.  If given resolution is out of range, 9 bits is used.\nReturn 1 in case of success, 0 otherwise.\n",
    "lang": "js"
  },
  {
    "name": "myDT.setWaitForConversion(waitForConversion)",
    "file": "[api_arduino_dallas_temp.js](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/mjs_fs/api_arduino_dallas_temp.js)",
    "doc": "\n```javascript\nmyDT.setWaitForConversion(waitForConversion)\n```\nSet/clear the waitForConversion flag.\nReturn value: none.\n",
    "lang": "js"
  },
  {
    "name": "myDT.getWaitForConversion()",
    "file": "[api_arduino_dallas_temp.js](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/mjs_fs/api_arduino_dallas_temp.js)",
    "doc": "\n```javascript\nmyDT.getWaitForConversion()\n```\nGet the value of the waitForConversion flag: either 1 or 0. In case\nof a failure, return 0.\n",
    "lang": "js"
  },
  {
    "name": "myDT.setCheckForConversion(checkForConversion)",
    "file": "[api_arduino_dallas_temp.js](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/mjs_fs/api_arduino_dallas_temp.js)",
    "doc": "\n```javascript\nmyDT.setCheckForConversion(checkForConversion)\n```\nSet/clear the `checkForConversion` flag.\n",
    "lang": "js"
  },
  {
    "name": "myDT.getCheckForConversion()",
    "file": "[api_arduino_dallas_temp.js](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/mjs_fs/api_arduino_dallas_temp.js)",
    "doc": "\n```javascript\nmyDT.getCheckForConversion()\n```\nGet the value of the `checkForConversion` flag: either 1 or 0. In case\nof a failure, return 0.\n",
    "lang": "js"
  },
  {
    "name": "myDT.requestTemperatures()",
    "file": "[api_arduino_dallas_temp.js](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/mjs_fs/api_arduino_dallas_temp.js)",
    "doc": "\n```javascript\nmyDT.requestTemperatures()\n```\nSend command for all devices on the bus to perform a temperature\nconversion.\n\nReturn value: 1 in case of success, 0 otherwise.\n",
    "lang": "js"
  },
  {
    "name": "myDT.requestTemperaturesByAddress(addr)",
    "file": "[api_arduino_dallas_temp.js](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/mjs_fs/api_arduino_dallas_temp.js)",
    "doc": "\n```javascript\nmyDT.requestTemperaturesByAddress(addr)\n```\nSend command to a device with the given onewire address `addr` to\nperform a temperature conversion.\n\nReturn value: 1 in case of success, 0 otherwise.\n",
    "lang": "js"
  },
  {
    "name": "myDT.requestTemperaturesByIndex(idx)",
    "file": "[api_arduino_dallas_temp.js](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/mjs_fs/api_arduino_dallas_temp.js)",
    "doc": "\n```javascript\nmyDT.requestTemperaturesByIndex(idx)\n```\nSend command to a device with the given index `idx` to perform a\ntemperature conversion.\n\nReturn value: 1 in case of success, 0 otherwise.\n",
    "lang": "js"
  },
  {
    "name": "myDT.getTemp(addr)",
    "file": "[api_arduino_dallas_temp.js](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/mjs_fs/api_arduino_dallas_temp.js)",
    "doc": "\n```javascript\nmyDT.getTemp(addr)\n```\nReturn raw temperature value (12 bit integer of 1/128 degrees C)\nor `DallasTemperature.DEVICE_DISCONNECTED_RAW` in case of a failure.\n",
    "lang": "js"
  },
  {
    "name": "myDT.getTempC(addr)",
    "file": "[api_arduino_dallas_temp.js](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/mjs_fs/api_arduino_dallas_temp.js)",
    "doc": "\n```javascript\nmyDT.getTempC(addr)\n```\nReturns temperature in degrees C or\n`DallasTemperature.DEVICE_DISCONNECTED_C` in case of a failure.\n",
    "lang": "js"
  },
  {
    "name": "myDT.getTempF(addr)",
    "file": "[api_arduino_dallas_temp.js](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/mjs_fs/api_arduino_dallas_temp.js)",
    "doc": "\n```javascript\nmyDT.getTempF(addr)\n```\nReturns temperature in degrees F or\n`DallasTemperature.DEVICE_DISCONNECTED_F` in case of a failure.\n",
    "lang": "js"
  },
  {
    "name": "myDT.getTempCByIndex(idx)",
    "file": "[api_arduino_dallas_temp.js](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/mjs_fs/api_arduino_dallas_temp.js)",
    "doc": "\n```javascript\nmyDT.getTempCByIndex(idx)\n```\nGet temperature from the device with the given index `idx` in degrees C,\nor `DallasTemperature.DEVICE_DISCONNECTED_C` in case of a failure.\n",
    "lang": "js"
  },
  {
    "name": "myDT.getTempFByIndex(idx)",
    "file": "[api_arduino_dallas_temp.js](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/mjs_fs/api_arduino_dallas_temp.js)",
    "doc": "\n```javascript\nmyDT.getTempFByIndex(idx)\n```\nGet temperature from the device with the given index `idx` in degrees F,\nor `DallasTemperature.DEVICE_DISCONNECTED_F` in case of a failure.\n",
    "lang": "js"
  },
  {
    "name": "myDT.isParasitePowerMode()",
    "file": "[api_arduino_dallas_temp.js](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/mjs_fs/api_arduino_dallas_temp.js)",
    "doc": "\n```javascript\nmyDT.isParasitePowerMode()\n```\nReturn 1 if the bus requires parasite power, 0 otherwise. In case of a\nfailure return 0.\n",
    "lang": "js"
  },
  {
    "name": "myDT.isConversionComplete()",
    "file": "[api_arduino_dallas_temp.js](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/mjs_fs/api_arduino_dallas_temp.js)",
    "doc": "\n```javascript\nmyDT.isConversionComplete()\n```\nReturn whether a conversion is completed.\n",
    "lang": "js"
  },
  {
    "name": "myDT.millisToWaitForConversion(res)",
    "file": "[api_arduino_dallas_temp.js](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/mjs_fs/api_arduino_dallas_temp.js)",
    "doc": "\n```javascript\nmyDT.millisToWaitForConversion(res)\n```\nReturn number of milliseconds to wait until the conversion is completed\nfor the given resolution `res` in bits (9, 10, 11 or 12).\nIn case of a failure, return 0.\n",
    "lang": "js"
  },
  {
    "name": "myDT.setHighAlarmTemp(grc)",
    "file": "[api_arduino_dallas_temp.js](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/mjs_fs/api_arduino_dallas_temp.js)",
    "doc": "\n```javascript\nmyDT.setHighAlarmTemp(grc)\n```\nSet the upper alarm temperature (in degrees C) for a device; valid range\nfor `grc` is from -55 to 125.\nReturn value: none.\n",
    "lang": "js"
  },
  {
    "name": "myDT.setLowAlarmTemp()",
    "file": "[api_arduino_dallas_temp.js](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/mjs_fs/api_arduino_dallas_temp.js)",
    "doc": "\n```javascript\nmyDT.setLowAlarmTemp()\n```\nSet the lower alarm temperature (in degrees C) for a device; valid range\nfor `grc` is from -55 to 125.\nReturn value: none.\n",
    "lang": "js"
  },
  {
    "name": "myDT.getHighAlarmTemp()",
    "file": "[api_arduino_dallas_temp.js](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/mjs_fs/api_arduino_dallas_temp.js)",
    "doc": "\n```javascript\nmyDT.getHighAlarmTemp()\n```\nReturn upper alarm temperature in degrees C (from -55 to 125), or\n`DallasTemperature.DEVICE_DISCONNECTED_C` in case of a failure.\n",
    "lang": "js"
  },
  {
    "name": "myDT.getHighAlarmTemp()",
    "file": "[api_arduino_dallas_temp.js](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/mjs_fs/api_arduino_dallas_temp.js)",
    "doc": "\n```javascript\nmyDT.getHighAlarmTemp()\n```\nReturn lower alarm temperature in degrees C (from -55 to 125), or\n`DallasTemperature.DEVICE_DISCONNECTED_C` in case of a failure.\n",
    "lang": "js"
  },
  {
    "name": "myDT.alarmSearch(addr)",
    "file": "[api_arduino_dallas_temp.js](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/mjs_fs/api_arduino_dallas_temp.js)",
    "doc": "\n```javascript\nmyDT.alarmSearch(addr)\n```\nSearch the wire for devices with active alarms.\n\n`addr` should be a string buffer of at least 8 bytes.\n\nIf the next device is found, 1 is returned and the device's address\nis written to `addr`; otherwise 0 is returned.\n\nUse `myDT.resetAlarmSearch()` to start over.\nExample:\n```javascript\nload(\"api_sys.js\");\nload(\"api_arduino_dallas_temp.js\");\n\nprint(\"Looking for devices with active alarms...\");\nlet addr = Sys._sbuf(8);\nwhile (myDT.alarmSearch(addr) === 1) {\n  print(\"Found:\", addr);\n}\nprint(\"Done.\");\n```\n",
    "lang": "js"
  },
  {
    "name": "myDT.resetAlarmSearch()",
    "file": "[api_arduino_dallas_temp.js](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/mjs_fs/api_arduino_dallas_temp.js)",
    "doc": "\n```javascript\nmyDT.resetAlarmSearch()\n```\nReset alarm search.\nReturn value: none.\n",
    "lang": "js"
  },
  {
    "name": "myDT.hasAlarm(addr)",
    "file": "[api_arduino_dallas_temp.js](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/mjs_fs/api_arduino_dallas_temp.js)",
    "doc": "\n```javascript\nmyDT.hasAlarm(addr)\n```\nReturn 1 if device with the given onewire address has active alarm;\n0 otherwise. In case of a failure, 0 is returned.\n",
    "lang": "js"
  },
  {
    "name": "myDT.hasAlarms()",
    "file": "[api_arduino_dallas_temp.js](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/mjs_fs/api_arduino_dallas_temp.js)",
    "doc": "\n```javascript\nmyDT.hasAlarms()\n```\nReturn 1 if any device on the bus has active alarm; 0 otherwise.\nIn case of a failure, 0 is returned.\n",
    "lang": "js"
  },
  {
    "name": "myDT.toHexStr(addr)",
    "file": "[api_arduino_dallas_temp.js](https://github.com/mongoose-os-libs/arduino-dallas-temperature/blob/master/mjs_fs/api_arduino_dallas_temp.js)",
    "doc": "\n```javascript\nmyDT.toHexStr(addr)\n```\nReturn device address `addr` in the hex format.\n",
    "lang": "js"
  },
  {
    "name": "DS3231.create()",
    "file": "[api_ds3231.js](https://github.com/mongoose-os-libs/arduino-ds3231/blob/master/mjs_fs/api_ds3231.js)",
    "doc": "\n```javascript\nDS3231.create()\n```\nCreate an instance of DS3231 with the methods described below.\n",
    "lang": "js"
  },
  {
    "name": "myds.setVoltage()",
    "file": "[api_ds3231.js](https://github.com/mongoose-os-libs/arduino-ds3231/blob/master/mjs_fs/api_ds3231.js)",
    "doc": "\n```javascript\nmyds.setVoltage()\n```\nDestroy `myds` instance; it's illegal to call any methods on that instance\nafterwards.\nReturn value: none.\n",
    "lang": "js"
  },
  {
    "name": "myds.setTimeSeconds(seconds)",
    "file": "[api_ds3231.js](https://github.com/mongoose-os-libs/arduino-ds3231/blob/master/mjs_fs/api_ds3231.js)",
    "doc": "\n```javascript\nmyds.setTimeSeconds(seconds)\n```\nSet seconds, 0 to 59.\nReturn value: none.\n",
    "lang": "js"
  },
  {
    "name": "myds.setTimeMinutes(minutes)",
    "file": "[api_ds3231.js](https://github.com/mongoose-os-libs/arduino-ds3231/blob/master/mjs_fs/api_ds3231.js)",
    "doc": "\n```javascript\nmyds.setTimeMinutes(minutes)\n```\nSet minutes, 0 to 59.\nReturn value: none.\n",
    "lang": "js"
  },
  {
    "name": "myds.setTimeHours(hours)",
    "file": "[api_ds3231.js](https://github.com/mongoose-os-libs/arduino-ds3231/blob/master/mjs_fs/api_ds3231.js)",
    "doc": "\n```javascript\nmyds.setTimeHours(hours)\n```\nSet hours, 0 to 23.\nReturn value: none.\n",
    "lang": "js"
  },
  {
    "name": "myds.setTimeDayOfTheWeek(dayOfTheWeekDay)",
    "file": "[api_ds3231.js](https://github.com/mongoose-os-libs/arduino-ds3231/blob/master/mjs_fs/api_ds3231.js)",
    "doc": "\n```javascript\nmyds.setTimeDayOfTheWeek(dayOfTheWeekDay)\n```\nSet day of the week, 1 to 7.\nReturn value: none.\n",
    "lang": "js"
  },
  {
    "name": "myds.setTimeDate(date)",
    "file": "[api_ds3231.js](https://github.com/mongoose-os-libs/arduino-ds3231/blob/master/mjs_fs/api_ds3231.js)",
    "doc": "\n```javascript\nmyds.setTimeDate(date)\n```\nSet day of month, 1 to 31.\nReturn value: none.\n",
    "lang": "js"
  },
  {
    "name": "myds.setTimeMonth(month)",
    "file": "[api_ds3231.js](https://github.com/mongoose-os-libs/arduino-ds3231/blob/master/mjs_fs/api_ds3231.js)",
    "doc": "\n```javascript\nmyds.setTimeMonth(month)\n```\nSet month, 1 to 12\nReturn value: none.\n",
    "lang": "js"
  },
  {
    "name": "myds.setTimeYear(twoDigitYear)",
    "file": "[api_ds3231.js](https://github.com/mongoose-os-libs/arduino-ds3231/blob/master/mjs_fs/api_ds3231.js)",
    "doc": "\n```javascript\nmyds.setTimeYear(twoDigitYear)\n```\nSet two last digits of the year, 0 to 99.\nReturn value: none.\n",
    "lang": "js"
  },
  {
    "name": "myds.getTimeSeconds()",
    "file": "[api_ds3231.js](https://github.com/mongoose-os-libs/arduino-ds3231/blob/master/mjs_fs/api_ds3231.js)",
    "doc": "\n```javascript\nmyds.getTimeSeconds()\n```\nGet seconds, 0 to 59.\n",
    "lang": "js"
  },
  {
    "name": "myds.getTimeMinutes()",
    "file": "[api_ds3231.js](https://github.com/mongoose-os-libs/arduino-ds3231/blob/master/mjs_fs/api_ds3231.js)",
    "doc": "\n```javascript\nmyds.getTimeMinutes()\n```\nGet minutes, 0 to 59.\n",
    "lang": "js"
  },
  {
    "name": "myds.getTimeHours()",
    "file": "[api_ds3231.js](https://github.com/mongoose-os-libs/arduino-ds3231/blob/master/mjs_fs/api_ds3231.js)",
    "doc": "\n```javascript\nmyds.getTimeHours()\n```\nGet hours, 0 to 23.\n",
    "lang": "js"
  },
  {
    "name": "myds.getTimeHoursIs12HourClock()",
    "file": "[api_ds3231.js](https://github.com/mongoose-os-libs/arduino-ds3231/blob/master/mjs_fs/api_ds3231.js)",
    "doc": "\n```javascript\nmyds.getTimeHoursIs12HourClock()\n```\nReturn 1 if 12-hour format is used, 0 otherwise.\n",
    "lang": "js"
  },
  {
    "name": "myds.getTimeHoursIsPM()",
    "file": "[api_ds3231.js](https://github.com/mongoose-os-libs/arduino-ds3231/blob/master/mjs_fs/api_ds3231.js)",
    "doc": "\n```javascript\nmyds.getTimeHoursIsPM()\n```\nReturn 1 if it's later than the noon.\n",
    "lang": "js"
  },
  {
    "name": "myds.getTimeDayOfTheWeek()",
    "file": "[api_ds3231.js](https://github.com/mongoose-os-libs/arduino-ds3231/blob/master/mjs_fs/api_ds3231.js)",
    "doc": "\n```javascript\nmyds.getTimeDayOfTheWeek()\n```\nGet day of week, 1 to 7.\n",
    "lang": "js"
  },
  {
    "name": "myds.getTimeDate()",
    "file": "[api_ds3231.js](https://github.com/mongoose-os-libs/arduino-ds3231/blob/master/mjs_fs/api_ds3231.js)",
    "doc": "\n```javascript\nmyds.getTimeDate()\n```\nGet day of month, 1 to 31.\n",
    "lang": "js"
  },
  {
    "name": "myds.getTimeMonth()",
    "file": "[api_ds3231.js](https://github.com/mongoose-os-libs/arduino-ds3231/blob/master/mjs_fs/api_ds3231.js)",
    "doc": "\n```javascript\nmyds.getTimeMonth()\n```\nGet month, 1 to 12.\n",
    "lang": "js"
  },
  {
    "name": "myds.getTimeYear()",
    "file": "[api_ds3231.js](https://github.com/mongoose-os-libs/arduino-ds3231/blob/master/mjs_fs/api_ds3231.js)",
    "doc": "\n```javascript\nmyds.getTimeYear()\n```\nGet last two digits of the year, 0 to 99.\n",
    "lang": "js"
  },
  {
    "name": "myds.getTimeYearCentury()",
    "file": "[api_ds3231.js](https://github.com/mongoose-os-libs/arduino-ds3231/blob/master/mjs_fs/api_ds3231.js)",
    "doc": "\n```javascript\nmyds.getTimeYearCentury()\n```\nReturn 1 if year is between 2100 and 2199; 0 otherwise.\n",
    "lang": "js"
  },
  {
    "name": "begin",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\nvoid begin(MD_MAX72XX *p);\n```\n> *\n> Initialize the object.\n> \n> Initialize the object data. This will be called to initialize\n> new data for the class that cannot be done during the object creation.\n> \n> \\param p\tpointer to the parent object for this zone.\n>    \n",
    "lang": "c"
  },
  {
    "name": "~MD_PZone",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\n~MD_PZone(void);\n```\n> *\n> Class Destructor.\n> \n> Release allocated memory and does the necessary to clean up once the object is\n> no longer required.\n>    \n",
    "lang": "c"
  },
  {
    "name": "zoneAnimate",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\nbool zoneAnimate(void);\n```\n> *\n> Animate the zone.\n> \n> Animate using the currently specified text and animation parameters.\n> This method is invoked from the main Parola object.\n> \n> \\return bool\ttrue if the zone animation has completed, false otherwise.\n>    \n",
    "lang": "c"
  },
  {
    "name": "getStatus",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\nbool getStatus(void) { return (_fsmState == END); }\n```\n> *\n> Get the completion status.\n> \n> Return the current completion status for the zone animation.\n> \n> See comments for the MD_Parola getZoneStatus() method.\n> \n> \\return bool\ttrue if the zone animation is completed\n>    \n",
    "lang": "c"
  },
  {
    "name": "zoneClear",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\nvoid zoneClear(void) { _MX->clear(_zoneStart, _zoneEnd); if (_inverted) _MX->transform(_zoneStart, _zoneEnd, MD_MAX72XX::TINV); };\n```\n> *\n> Clear the zone.\n> \n> See comments for the MD_Parola namesake method.\n> \n> \\return No return value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "zoneReset",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\ninline void zoneReset(void) { _fsmState = INITIALISE; };\n```\n> *\n> Reset the current zone animation to restart.\n> \n> See comments for the MD_Parola namesake method.\n> \n> \\return No return value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "zoneShutdown",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\nvoid zoneShutdown(bool b) { _MX->control(_zoneStart, _zoneEnd, MD_MAX72XX::SHUTDOWN, b ? MD_MAX72XX::ON : MD_MAX72XX::OFF); };\n```\n> *\n> Sshutdown or resume zone hardware.\n> \n> See comments for the MD_Parola namesake method.\n> \n> \\param b\tboolean value to shutdown (true) or resume (false).\n> \\return No return value.\n>   \n",
    "lang": "c"
  },
  {
    "name": "zoneSuspend",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\ninline void zoneSuspend(bool b) { _suspend = b; };\n```\n> *\n> Suspend or resume zone updates.\n> \n> See comments for the MD_Parola namesake method.\n> \n> \\param b\tboolean value to suspend (true) or resume (false).\n> \\return No return value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "setZone",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\ninline void setZone(uint8_t zStart, uint8_t zEnd) { _zoneStart = zStart; _zoneEnd = zEnd; };\n```\n> *\n> Set the start and end parameters for a zone.\n> \n> See comments for the MD_Parola namesake method.\n> \n> \\param zStart\tthe first module number for the zone [0..numZones-1].\n> \\param zEnd\tthe last module number for the zone [0..numZones-1].\n>    \n",
    "lang": "c"
  },
  {
    "name": "getCharSpacing",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\ninline uint8_t getCharSpacing(void) { return _charSpacing; };\n```\n> *\n> Get the zone inter-character spacing in columns.\n> \n> \\return the current setting for the space between characters in columns.\n>    \n",
    "lang": "c"
  },
  {
    "name": "getIntensity",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\ninline uint8_t getIntensity() { return _intensity; };\n```\n> *\n> Get the zone brightness.\n> \n> Get the intensity (brightness) of the display.\n> \n> \\return The intensity setting.\n>   \n",
    "lang": "c"
  },
  {
    "name": "getInvert",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\ninline bool getInvert(void) { return _inverted; };\n```\n> *\n> Get the zone current invert state.\n> \n> See the setInvert() method.\n> \n> \\return the inverted boolean value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "getPause",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\ninline uint16_t getPause(void) { return _pauseTime; };\n```\n> *\n> Get the zone pause time.\n> \n> See the setPause() method.\n> \n> \\return the pause value in milliseconds.\n>    \n",
    "lang": "c"
  },
  {
    "name": "getScrollSpacing",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\ninline uint16_t getScrollSpacing(void) { return _scrollDistance; };\n```\n> *\n> Get the horizontal Scroll spcing.\n> \n> See the setScrollSpacing() method\n> \n> \\return the space between message in columns.\n>    \n",
    "lang": "c"
  },
  {
    "name": "getSpeed",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\ninline uint16_t getSpeed(void) { return _tickTime; };\n```\n> *\n> Get the zone animation speed.\n> \n> See the setSpeed() method\n> \n> \\return the speed value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "getSynchTime",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\ninline uint32_t getSynchTime(void) { return _lastRunTime; }\n```\n> *\n> Get the zone animation start time.\n> \n> See the setSynchTime() method\n> \n> \\return the internal time reference.\n>   \n",
    "lang": "c"
  },
  {
    "name": "getTextAlignment",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\ninline textPosition_t getTextAlignment(void) { return _textAlignment; };\n```\n> *\n> Get the current text alignment specification.\n> \n> \\return the current text alignment setting\n>    \n",
    "lang": "c"
  },
  {
    "name": "getZoneEffect",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\nboolean getZoneEffect(zoneEffect_t ze);\n```\n> *\n> Get the value of specified display effect.\n> \n> The display effect is one of the zoneEffect_t types. The returned value will be\n> true if the attribute is set, false if the attribute is not set.\n> \n> \\param ze\tthe required text alignment.\n> \\return true if the value is set, false otherwise.\n>    \n",
    "lang": "c"
  },
  {
    "name": "setCharSpacing",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\ninline void setCharSpacing(uint8_t cs) { _charSpacing = cs; allocateFontBuffer(); };\n```\n> *\n> Set the zone inter-character spacing in columns.\n> \n> Set the number of blank columns between characters when they are displayed.\n> \n> \\param cs\tspace between characters in columns.\n> \\return No return value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "setIntensity",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\ninline void setIntensity(uint8_t intensity) { _intensity = intensity; _MX->control(_zoneStart, _zoneEnd, MD_MAX72XX::INTENSITY, _intensity); };\n```\n> *\n> Set the zone brightness.\n> \n> Set the intensity (brightness) of the display.\n> \n> \\param intensity\tthe intensity to set the display (0-15).\n> \\return No return value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "setInvert",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\ninline void setInvert(uint8_t invert) { _inverted = invert; };\n```\n> *\n> Invert the zone display.\n> \n> Set the display to inverted (ON LED turns OFF and vice versa).\n> \n> \\param invert\ttrue for inverted display, false for normal display\n> \\return No return value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "setPause",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\ninline void setPause(uint16_t pause) { _pauseTime = pause; };\n```\n> *\n> Set the pause between ENTER and EXIT animations for this zone.\n> \n> Between each entry and exit, the library will pause by the number of milliseconds\n> specified to allow the viewer to read the message. For continuous scrolling displays\n> this should be set to the same value as the display speed.\n> \n> \\param pause\tthe time, in milliseconds, between animations.\n> \\return No return value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "setScrollSpacing",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\ninline void setScrollSpacing(uint16_t space) { _scrollDistance = space; };\n```\n> *\n> Set the horizontal scrolling distance between messages.\n> \n> When scrolling horizontally, the distance between the end of one message and the\n> start of the next can be set using this method. Normal operation is for the message\n> to be fully off the display before the new message starts.\n> Set to zero for default behavior.\n> \n> \\param space\tthe spacing, in columns, between messages; zero for default behaviour..\n> \\return No return value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "setSpeed",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\ninline void setSpeed(uint16_t speed) { _tickTime = speed; };\n```\n> *\n> Set the zone animation frame speed.\n> \n> The speed of the display is the 'tick' time between animation frames. The lower this time\n> the faster the animation; set it to zero to run as fast as possible.\n> \n> \\param speed\tthe time, in milliseconds, between animation frames.\n> \\return No return value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "setSynchTime",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\ninline void setSynchTime(uint32_t zt) { _lastRunTime = zt; }\n```\n> *\n> Set the zone animation start time.\n> \n> Each zone animation has an associated start time. The start time\n> defaults to the time when the zone is initialised. This method allows\n> synchronisation between zones by setting the same start time. Should be\n> used in conjunction with the getSynchTime() method as the return value\n> should only be treated as an internal reference and arbitrary values\n> will result in irregular behaviour.\n> \n> \\param zt\tthe required start time.\n> \\return No return value.\n>   \n",
    "lang": "c"
  },
  {
    "name": "setTextAlignment",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\ninline void setTextAlignment(textPosition_t ta) { _textAlignment = ta; };\n```\n> *\n> Set the text alignment within the zone.\n> \n> Text alignment is specified as one of the values in textPosition_t.\n> \n> \\param ta\tthe required text alignment.\n> \\return No return value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "setTextBuffer",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\ninline void setTextBuffer(char *pb) { _pText = pb; };\n```\n> *\n> Set the pointer to the text buffer for this zone.\n> \n> Sets the text buffer to be a pointer to user data.\n> See the comments for the namesake method in MD_Parola.\n> \n> \\param pb\tpointer to the text buffer to be used.\n> \\return No return value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "setTextEffect",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\ninline void setTextEffect(textEffect_t effectIn, textEffect_t effectOut) { _effectIn = effectIn, _effectOut = effectOut; };\n```\n> *\n> Set the entry and exit text effects for the zone.\n> \n> See the comments for the namesake method in MD_Parola.\n> \n> \\param\teffectIn\tthe entry effect, one of the textEffect_t enumerated values.\n> \\param\teffectOut\tthe exit effect, one of the textEffect_t enumerated values.\n> \\return No return value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "setZoneEffect",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\nvoid setZoneEffect(boolean b, zoneEffect_t ze);\n```\n> *\n> Set the zone display effect.\n> \n> The display effect is one of the zoneEffect_t types, and this will be set (true) or\n> reset (false) depending on the boolean value. The resulting zone display will be\n> modified as per the required effect.\n> \n> \\param b set the value if true, reset the value if false\n> \\param ze\tthe required text alignment.\n> \\return No return value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "addChar",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\nbool addChar(uint8_t code, uint8_t *data);\n```\n> *\n> Add a user defined character to the replacement list.\n> \n> Add a replacement characters to the user defined list. The character data must be\n> the same as for a single character in the font definition file. If a character is\n> specified with a code the same as an existing character the existing data will be\n> substituted for the new data. A character code of 0 is illegal as this denotes the\n> end of string character for C++ and cannot be used in an actual string.\n> The library does not copy the in the data in the data definition but only retains\n> a pointer to the data, so any changes to the data storage in the calling program will\n> be reflected in the library.\n> \n> \\param code\tASCII code for the character data.\n> \\param data\tpointer to the character data.\n> \\return true of the character was inserted in the substitution list.\n>    \n",
    "lang": "c"
  },
  {
    "name": "delChar",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\nbool delChar(uint8_t code);\n```\n> *\n> Delete a user defined character to the replacement list.\n> \n> Delete a replacement character to the user defined list. A character code of 0 is\n> illegal as this denotes the end of string character for C++ and cannot be used in\n> an actual string.\n> \n> \\param code\tASCII code for the character data.\n> \\return true of the character was found in the substitution list.\n>    \n",
    "lang": "c"
  },
  {
    "name": "setZoneFont",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\nvoid setZoneFont(MD_MAX72XX::fontType_t *fontDef) { _fontDef = fontDef; _MX->setFont(_fontDef); allocateFontBuffer(); };\n  /** @} */\n```\n> *\n> Set the display font.\n> \n> See comments for the namesake Parola method.\n> \n> \\param fontDef\tPointer to the font definition to be used.\n> \\return No return value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "getTextWidth",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\nuint16_t  getTextWidth(char *p);      // width of text in columns\n  bool      calcTextLimits(char *p);    // calculate the right and left limits for the text\n```\n> set up initial conditions for an effect\n",
    "lang": "c"
  },
  {
    "name": "getNextChar",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\nuint8_t getNextChar(void);      // put the next Text char into the char buffer\n```\n> put the first Text char into the char buffer\n",
    "lang": "c"
  },
  {
    "name": "findChar",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\nuint8_t   findChar(uint8_t code, uint8_t size, uint8_t *cBuf);\t// look for user defined character\n  uint8_t   makeChar(char c, bool addBlank);      // load a character bitmap and add in trailing _charSpacing blanks if req'd\n  void      reverseBuf(uint8_t *p, uint8_t size); // reverse the elements of the buffer\n  void      invertBuf(uint8_t *p, uint8_t size);  // invert the elements of the buffer\n```\n> allocate _cBuf based on the size of the largest font characters\n",
    "lang": "c"
  },
  {
    "name": "state2string",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\nchar *state2string(fsmState_t s);\n```\n> Debugging aid\n",
    "lang": "c"
  },
  {
    "name": "commonPrint",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\nvoid  commonPrint(void);\n  void  effectPrint(bool bIn);\n//#if ENA_MISC\n  void  effectSlice(bool bIn);\n  void  effectMesh(bool bIn);\n  void  effectFade(bool bIn);\n  void  effectBlinds(bool bIn);\n  void  effectDissolve(bool bIn);\n  void  effectRandom(bool bIn);\n//#endif // ENA_MISC\n//#if ENA_WIPE\n  void  effectWipe(bool bLightBar, bool bIn);\n//#endif\n//#if ENA_OPNCLS\n  void  effectOpen(bool bLightBar, bool bIn);\n  void  effectClose(bool bLightBar, bool bIn);\n//#endif // ENA_OPNCLS\n//#if ENA_SCR_STR\n  void  effectVScroll(bool bUp, bool bIn);\n  void  effectHScroll(bool bLeft, bool bIn);\n//#endif // ENA_SCR_STR\n//#if ENA_SCR_DIA\n  void  effectDiag(bool bUp, bool bLeft, bool bIn);\n//#endif // ENA_SCR_DIA\n//#if ENA_SCAN\n  void  effectHScan(bool bIn, bool bBlank);\n  void  effectVScan(bool bIn, bool bBlank);\n//#endif // ENA_SCAN\n//#if ENA_GROW\n  void  effectGrow(bool bUp, bool bIn);\n//#endif // ENA_GROW\n};\n```\n> Effect functions\n",
    "lang": "c"
  },
  {
    "name": "MD_Parola",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\nMD_Parola(uint8_t csPin, uint8_t numDevices=1);\n```\n> *\n> Class Constructor - SPI hardware interface.\n> \n> Instantiate a new instance of the class. The parameters passed are used to\n> connect the software to the hardware using the MD_MAX72XX class.\n> \n> See documentation for the MD_MAX72XX library for detailed explanation of parameters.\n> \n> \\param csPin\t\toutput for selecting the device.\n> \\param numDevices\tnumber of devices connected. Default is 1 if not supplied.\n>    \n",
    "lang": "c"
  },
  {
    "name": "begin",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\nvoid begin(void) { begin(1); };\n```\n> *\n> Initialize the object.\n> \n> Initialise the object data. This needs to be called during setup() to initialise new\n> data for the class that cannot be done during the object creation. This form of the\n> method is for backward compatibility and creates one zone for the entire display.\n>    \n",
    "lang": "c"
  },
  {
    "name": "begin",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\nvoid begin(uint8_t numZones);\n```\n> *\n> Initialize the object.\n> \n> Initialise the object data. This needs to be called during setup() to initialise new\n> data for the class that cannot be done during the object creation. This form of the\n> method allows specifying the number of zones used. The maximum number of zones is set \n> by the MAX_ZONES constant which can be chanhed to allow more or fewer zones. The module\n> limits for the zones need to be initialized separately using setZone().\n> \n> \\param numZones\tmaximum number of zones [1..MAX_ZONES]\n>    \n",
    "lang": "c"
  },
  {
    "name": "~MD_Parola",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\n~MD_Parola(void);\n```\n> *\n> Class Destructor.\n> \n> Release allocated memory and does the necessary to clean up once the object is\n> no longer required.\n>    \n",
    "lang": "c"
  },
  {
    "name": "displayAnimate",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\nbool displayAnimate(void);\n```\n> *\n> Animate the display.\n> \n> Animate all the zones in the display using the currently specified text and\n> animation parameters. This method needs to be invoked as often as possible\n> to ensure smooth animation. The animation is governed by a time tick that\n> is set by the setSpeed() method and it will pause between entry and exit using\n> the time set by the setPause() method.\n> \n> The calling program should monitor the return value for 'true' in order to either\n> reset the zone animation or supply another string for display. A 'true' return\n> value means that one or more zones have completed their animation.\n> \n> \\return bool\ttrue if at least one zone animation has completed, false otherwise.\n>    \n",
    "lang": "c"
  },
  {
    "name": "getZoneStatus",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\nbool getZoneStatus(uint8_t z) { if (z < _numZones) return(_Z[z].getStatus()); };\n```\n> *\n> Get the completion status for a zone.\n> \n> This method is to determine which zone has completed when displayAnimate()\n> has returned a completion status.\n> \n> The calling program should monitor the return value for 'true' in order to either\n> reset the zone animation or supply another string for display. A 'true' return\n> value means that the zone has completed its animation cycle.\n> \n> \\param z\t\tspecified zone\n> \\return bool\ttrue if the zone animation has completed, false otherwise.\n>    \n",
    "lang": "c"
  },
  {
    "name": "displayClear",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\nvoid displayClear(void) { for (uint8_t i=0; i<_numZones; i++) _Z[i].zoneClear(); };\n```\n> *\n> Clear the display.\n> \n> Clear all the zones in the current display.\n> \n> \\return No return value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "displayClear",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\nvoid displayClear(uint8_t z) { if (z < _numZones) _Z[z].zoneClear(); };\n```\n> *\n> Clear one zone in the display.\n> \n> Clear the specified zone in the current display.\n> \n> \\param z\t\tspecified zone\n> \\return No return value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "displayReset",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\nvoid displayReset(void) { for (uint8_t i=0; i<_numZones; i++) _Z[i].zoneReset(); };\n```\n> *\n> Reset the current animation to restart for all zones.\n> \n> This method is used to reset all the zone animations an animation back to the start\n> of their cycle current cycle.\n> It is normally invoked after all the parameters for a display are set and the\n> animation needs to be started (or restarted).\n> \n> \\return No return value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "displayReset",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\nvoid displayReset(uint8_t z) { if (z < _numZones) _Z[z].zoneReset(); };\n```\n> *\n> Reset the current animation to restart for the specified zone.\n> \n> See the comments for the 'all zones' variant of this method.\n> \n> \\param z\tspecified zone\n> \\return No return value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "displayShutdown",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\nvoid displayShutdown(bool b) { for (uint8_t i=0; i<_numZones; i++) _Z[i].zoneShutdown(b); };\n```\n> *\n> Shutdown or restart display hardware.\n> \n> Shutdown the display hardware to a low power state. The display will\n> be blank during the shutdown. Calling animate() will continue to\n> animate the display in the memory buffers but this will not be visible\n> on the display (ie, the librarie still function but the display does not).\n> To reset the animation back to the beginning, use the displayReset() method.\n> \n> \\param b\tboolean value to shutdown (true) or resume (false).\n> \\return No return value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "displaySuspend",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\nvoid displaySuspend(bool b) { for (uint8_t i = 0; i<_numZones; i++) _Z[i].zoneSuspend(b); };\n```\n> *\n> Suspend or resume display updates.\n> \n> Stop the current display animation. When pausing it leaves the\n> display showing the current text. Resuming will restart the animation where\n> it left off. To reset the animation back to the beginning, use the\n> displayReset() method.\n> \n> \\param b\tboolean value to suspend (true) or resume (false).\n> \\return No return value.\n>   \n",
    "lang": "c"
  },
  {
    "name": "setZone",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\nbool setZone(uint8_t z, uint8_t moduleStart, uint8_t moduleEnd);\n```\n> *\n> Define the module limits for a zone.\n> \n> When multiple zones are defined, the library needs to know the contiguous module\n> ranges that make up the different zones. If the library has been started with only\n> one zone then it will automatically initialize the zone to be the entire range for\n> the display modules, so calling this function is not required.\n> \n> A module is a unit of 8x8 LEDs, as defined in the MD_MAX72xx library.\n> Zones should not overlap or unexpected results will occur.\n> \n> \\param z\t\tzone number.\n> \\param moduleStart\tthe first module number for the zone [0..numZones-1].\n> \\param moduleEnd\tthe last module number for the zone [0..numZones-1].\n> \\return true if set, false otherwise.\n>    \n",
    "lang": "c"
  },
  {
    "name": "displayScroll",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\ninline void displayScroll(char *pText, textPosition_t align, textEffect_t effect, uint16_t speed)\n    { displayZoneText(0, pText, align, speed, 0, effect, effect); };\n```\n> *\n> Easy start for a scrolling text display.\n> \n> This method is a convenient way to set up a scrolling display. All the data\n> necessary for setup is passed through as parameters and the display animation\n> is started. Assumes one zone only (zone 0).\n> \n> \\param pText\tparameter suitable for the setTextBuffer() method.\n> \\param align\tparameter suitable for the the setTextAlignment() method.\n> \\param effect\tparameter suitable for the the setTextEffect() method.\n> \\param speed\tparameter suitable for the setSpeed() method.\n> \\return No return value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "displayText",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\ninline void displayText(char *pText, textPosition_t align, uint16_t speed, uint16_t pause, textEffect_t effectIn, textEffect_t effectOut = PA_NO_EFFECT)\n    { displayZoneText(0, pText, align, speed, pause, effectIn, effectOut); };\n```\n> *\n> Easy start for a non-scrolling text display.\n> \n> This method is a convenient way to set up a static text display. All the data\n> necessary for setup is passed through as parameters and the display animation\n> is started. Assumes one zone only (zone 0).\n> \n> \\param pText\tparameter suitable for the setTextBuffer() method.\n> \\param align\tparameter suitable for the the setTextAlignment() method.\n> \\param speed\tparameter suitable for the setSpeed() method.\n> \\param pause\tparameter suitable for the setPause() method.\n> \\param\teffectIn\tparameter suitable for the setTextEffect() method.\n> \\param\teffectOut\tparameter suitable for the setTextEffect() method.\n> \\return No return value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "displayZoneText",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\nvoid displayZoneText(uint8_t z, char *pText, textPosition_t align, uint16_t speed, uint16_t pause, textEffect_t effectIn, textEffect_t effectOut = PA_NO_EFFECT);\n```\n> *\n> Easy start for a non-scrolling zone text display.\n> \n> This method is a convenient way to set up a static text display within the\n> specified zone. All the data necessary for setup is passed through as\n> parameters and the display animation is started.\n> \n> \\param z\t\tzone specified.\n> \\param pText\tparameter suitable for the setTextBuffer() method.\n> \\param align\tparameter suitable for the the setTextAlignment() method.\n> \\param speed\tparameter suitable for the setSpeed() method.\n> \\param pause\tparameter suitable for the setPause() method.\n> \\param\teffectIn\tparameter suitable for the setTextEffect() method.\n> \\param\teffectOut\tparameter suitable for the setTextEffect() method.\n> \\return No return value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "getCharSpacing",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\ninline uint8_t getCharSpacing(void) { return _Z[0].getCharSpacing(); };\n```\n> *\n> Get the inter-character spacing in columns.\n> \n> \\return the current setting for the space between characters in columns. Assumes one zone only.\n>    \n",
    "lang": "c"
  },
  {
    "name": "getCharSpacing",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\ninline uint8_t getCharSpacing(uint8_t z) { return (z < _numZones ? _Z[z].getCharSpacing() : 0); };\n```\n> *\n> Get the inter-character spacing in columns for a specific zone.\n> \n> \\param z\t\tzone number.\n> \\return the current setting for the space between characters in columns.\n>    \n",
    "lang": "c"
  },
  {
    "name": "getInvert",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\ninline bool getInvert(void) { return _Z[0].getInvert(); };\n```\n> *\n> Get the current display invert state.\n> \n> See the setInvert() method.\n> \n> \\return true if the display is inverted. Assumes one zone only.\n>    \n",
    "lang": "c"
  },
  {
    "name": "getInvert",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\ninline bool getInvert(uint8_t z) { return (z < _numZones ? _Z[z].getInvert() : false); };\n```\n> *\n> Get the current display invert state for a specific zone.\n> \n> See the setInvert() method.\n> \n> \\param z\t\tzone number.\n> \\return the inverted boolean value for the specified zone.\n>    \n",
    "lang": "c"
  },
  {
    "name": "getPause",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\ninline uint16_t getPause(void) { return _Z[0].getPause(); };\n```\n> *\n> Get the current pause time.\n> \n> See the setPause() method. Assumes one zone only.\n> \n> \\return the pause value in milliseconds.\n>    \n",
    "lang": "c"
  },
  {
    "name": "getPause",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\ninline uint16_t getPause(uint8_t z) { return (z < _numZones ? _Z[z].getPause() : 0); };\n```\n> *\n> Get the current pause time for a specific zone.\n> \n> See the setPause() method.\n> \n> \\param z\t\tzone number.\n> \\return the pause value in milliseconds for the specified zone.\n>    \n",
    "lang": "c"
  },
  {
    "name": "getScrollSpacing",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\ninline uint16_t getScrollSpacing(void) { return _Z[0].getScrollSpacing(); };\n```\n> *\n> Get the horizontal scrolling spacing.\n> \n> See the setScrollSpacing() method. Assumes one zone only\n> \n> \\return the speed value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "getSpeed",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\ninline uint16_t getSpeed(void) { return _Z[0].getSpeed(); };\n```\n> *\n> Get the current animation speed.\n> \n> See the setSpeed() method. Assumes one zone only\n> \n> \\return the speed value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "getSpeed",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\ninline uint16_t getSpeed(uint8_t z) { return (z < _numZones ? _Z[z].getSpeed() : 0); };\n```\n> *\n> Get the current animation speed for the specified zone.\n> \n> See the setSpeed() method.\n> \n> \\param z\t\tzone number.\n> \\return the speed value for the specified zone.\n>    \n",
    "lang": "c"
  },
  {
    "name": "getTextAlignment",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\ninline textPosition_t getTextAlignment(void) { return _Z[0].getTextAlignment(); };\n```\n> *\n> Get the current text alignment specification.\n> \n> Assumes one zone only.\n> \n> \\return the current text alignment setting.\n>    \n",
    "lang": "c"
  },
  {
    "name": "getTextAlignment",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\ninline textPosition_t getTextAlignment(uint8_t z) { return (z < _numZones ? _Z[z].getTextAlignment() : PA_CENTER); };\n```\n> *\n> Get the current text alignment specification for the specified zone.\n> \n> \\param z\t\tzone number.\n> \\return the current text alignment setting for the specified zone.\n>    \n",
    "lang": "c"
  },
  {
    "name": "getZoneEffect",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\ninline boolean getZoneEffect(uint8_t z, zoneEffect_t ze) { return (z < _numZones ? _Z[z].getZoneEffect(ze) : false); };\n```\n> *\n> Get the value of specified display effect.\n> \n> The display effect is one of the zoneEffect_t types. The returned value will be\n> true if the attribute is set, false if the attribute is not set.\n> \n> \\param z   zone number.\n> \\param ze  the required text alignment.\n> \\return true if the value is set, false otherwise.\n>    \n",
    "lang": "c"
  },
  {
    "name": "setCharSpacing",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\nvoid setCharSpacing(uint8_t cs) { for (uint8_t i=0; i<_numZones; i++) _Z[i].setCharSpacing(cs); };\n```\n> *\n> Set the inter-character spacing in columns for all zones.\n> \n> Set the number of blank columns between characters when they are displayed.\n> \n> \\param cs\tspace between characters in columns.\n> \\return No return value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "setCharSpacing",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\ninline void setCharSpacing(uint8_t z, uint8_t cs) { if (z < _numZones) _Z[z].setCharSpacing(cs); };\n```\n> *\n> Set the inter-character spacing in columns for the specified zone.\n> \n> See comments for the 'all zones' variant of this method.\n> \n> \\param z\tzone number.\n> \\param cs\tspace between characters in columns.\n> \\return No return value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "setIntensity",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\nvoid setIntensity(uint8_t intensity) { for (uint8_t i=0; i<_numZones; i++) _Z[i].setIntensity(intensity); };\n```\n> *\n> Set the display brightness for all the zones.\n> \n> Set the intensity (brightness) of the display.\n> \n> \\param intensity\tthe intensity to set the display (0-15).\n> \\return No return value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "setIntensity",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\ninline void setIntensity(uint8_t z, uint8_t intensity) { if (z < _numZones) _Z[z].setIntensity(intensity); };\n```\n> *\n> Set the display brightness for the specified zone.\n> \n> See comments for the 'all zones' variant of this method.\n> \n> \\param z\t\t\tzone number.\n> \\param intensity\tthe intensity to set the display (0-15).\n> \\return No return value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "setInvert",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\nvoid setInvert(uint8_t invert) { for (uint8_t i=0; i<_numZones; i++) _Z[i].setInvert(invert); };\n```\n> *\n> Invert the display in all the zones.\n> \n> Set the display to inverted (ON LED turns OFF and vice versa).\n> \n> \\param invert\ttrue for inverted display, false for normal display\n> \\return No return value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "setInvert",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\ninline void setInvert(uint8_t z, uint8_t invert) { if (z < _numZones) _Z[z].setInvert(invert); };\n```\n> *\n> Invert the display in the specified zone.\n> \n> See comments for the 'all zones' variant of this method.\n> \n> \\param z\t\tzone number.\n> \\param invert\ttrue for inverted display, false for normal display\n> \\return No return value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "setPause",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\nvoid setPause(uint16_t pause) { for (uint8_t i=0; i<_numZones; i++) _Z[i].setPause(pause); };\n```\n> *\n> Set the pause between ENTER and EXIT animations for all zones.\n> \n> Between each entry and exit, the library will pause by the number of milliseconds\n> specified to allow the viewer to read the message. For continuous scrolling displays\n> this should be set to the same value as the display speed.\n> \n> \\param pause\tthe time, in milliseconds, between animations.\n> \\return No return value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "setPause",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\nvoid setPause(uint8_t z, uint16_t pause) { if (z < _numZones) _Z[z].setPause(pause); };\n```\n> *\n> Set the pause between ENTER and EXIT animations for the specified zone.\n> \n> See comments for the 'all zones' variant of this method.\n> \n> \\param z\t\tzone number.\n> \\param pause\tthe time, in milliseconds, between animations.\n> \\return No return value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "setScrollSpacing",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\nvoid setScrollSpacing(uint16_t space) { for (uint8_t i=0; i<_numZones; i++) _Z[i].setScrollSpacing(space); };\n```\n> *\n> Set the horizontal scrolling distance between messages for all the zones.\n> \n> When scrolling horizontally, the distance between the end of one message and the\n> start of the next can be set using this method. Default behavior is for the message\n> to be fully off the display before the new message starts.\n> Set to zero for default behavior.\n> \n> \\param space\tthe spacing, in columns, between messages; zero for default behaviour..\n> \\return No return value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "setSpeed",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\nvoid setSpeed(uint16_t speed) { for (uint8_t i=0; i<_numZones; i++) _Z[i].setSpeed(speed); };\n```\n> *\n> Set the animation frame speed for all zones.\n> \n> The speed of the display is the 'tick' time between animation frames. The lower this time\n> the faster the animation; set it to zero to run as fast as possible.\n> \n> \\param speed\tthe time, in milliseconds, between animation frames.\n> \\return No return value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "setSpeed",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\ninline void setSpeed(uint8_t z, uint16_t speed) { if (z < _numZones) _Z[z].setSpeed(speed); };\n```\n> *\n> Set the animation frame speed for the specified zone.\n> \n> See comments for the 'all zones' variant of this method.\n> \n> \\param z\t\tzone number.\n> \\param speed\tthe time, in milliseconds, between animation frames.\n> \\return No return value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "setTextAlignment",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\nvoid setTextAlignment(textPosition_t ta) { for (uint8_t i=0; i<_numZones; i++) _Z[i].setTextAlignment(ta); };\n```\n> *\n> Set the text alignment for all zones.\n> \n> Text alignment is specified as one of the values in textPosition_t.\n> \n> \\param ta\tthe required text alignment.\n> \\return No return value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "setTextAlignment",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\ninline void setTextAlignment(uint8_t z, textPosition_t ta) { if (z < _numZones) _Z[z].setTextAlignment(ta); };\n```\n> *\n> Set the text alignment for the specified zone.\n> \n> See comments for the 'all zones' variant of this method.\n> \n> \\param z\tzone number.\n> \\param ta\tthe required text alignment.\n> \\return No return value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "setTextBuffer",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\nvoid setTextBuffer(char *pb) { /*for (uint8_t i = 0; i<_numZones; i++) */_Z[0].setTextBuffer(pb); };\n```\n> *\n> Set the pointer to the text buffer.\n> \n> Sets the text buffer to be a pointer to user data. The library does not allocate\n> any memory for the text message, rather it is the calling program that supplies\n> a pointer to a buffer. This reduces memory requirements and offers the flexibility\n> to keep a single buffer or rotate buffers with different messages, all under calling\n> program control, with no library limit to the size or numbers of buffers. The text\n> placed in the buffer must be properly terminated by the NUL ('\\0') character or\n> processing will overrun the end of the message.\n> \n> This form of the method assumes one zone only.\n> \n> \\param pb\tpointer to the text buffer to be used.\n> \\return No return value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "setTextBuffer",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\ninline void setTextBuffer(uint8_t z, char *pb) { if (z < _numZones) _Z[z].setTextBuffer(pb); };\n```\n> *\n> Set the pointer to the text buffer for the specified zone.\n> \n> See comments for the single zone version of this method.\n> \n> \\param z\tzone number.\n> \\param pb\tpointer to the text buffer to be used.\n> \\return No return value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "setTextEffect",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\nvoid setTextEffect(textEffect_t effectIn, textEffect_t effectOut) { for (uint8_t i = 0; i < _numZones; i++) _Z[i].setTextEffect(effectIn, effectOut); };\n```\n> *\n> Set the entry and exit text effects for all zones.\n> \n> The 'in' and 'out' text effects are specified using the textEffect_t enumerated\n> type. If no effect is required, NO_EFFECT should be specified. NO_EFFECT\n> is most useful when no exit effect is required (e.g., when DISSOLVE is used) and\n> the entry effect is sufficient.\n> \n> \\param\teffectIn\tthe entry effect, one of the textEffect_t enumerated values.\n> \\param\teffectOut\tthe exit effect, one of the textEffect_t enumerated values.\n> \\return No return value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "setTextEffect",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\ninline void setTextEffect(uint8_t z, textEffect_t effectIn, textEffect_t effectOut) { if (z < _numZones) _Z[z].setTextEffect(effectIn, effectOut); };\n```\n> *\n> Set the entry and exit text effects for a specific zone.\n> \n> See comments for the 'all zones' variant of this method.\n> \n> \\param z\t\t\tzone number.\n> \\param\teffectIn\tthe entry effect, one of the textEffect_t enumerated values.\n> \\param\teffectOut\tthe exit effect, one of the textEffect_t enumerated values.\n> \\return No return value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "setZoneEffect",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\ninline void setZoneEffect(uint8_t z, boolean b, zoneEffect_t ze) { if (z < _numZones) _Z[z].setZoneEffect(b, ze); };\n```\n> *\n> Set the display effect for the specified zone.\n> \n> The display effect is one of the zoneEffect_t types, and this will be set (true) or\n> reset (false) depending on the boolean value. The resulting zone display will be\n> modified as per the required effect.\n> \n> \\param z   zone number.\n> \\param b   set the value if true, reset the value if false\n> \\param ze  the required text alignment.\n> \\return No return value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "synchZoneStart",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\nvoid synchZoneStart(void) { for (uint8_t i = 1; i < _numZones; i++) _Z[i].setSynchTime(_Z[0].getSynchTime()); }\n```\n> *\n> Synchronise the start of zone animations.\n> \n> When zones are set up, the animation start time will default\n> to the set-up time. If several zones need to be animated\n> in synchronised fashion (eg, they are visually stacked vertically),\n> this method will ensure that all the zones start at the same instant.\n> \n> \\return No return value.\n>   \n",
    "lang": "c"
  },
  {
    "name": "addChar",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\nvoid addChar(uint8_t code, uint8_t *data) { for (uint8_t i=0; i<_numZones; i++) _Z[i].addChar(code, data); };\n```\n> *\n> Add a user defined character to the replacement list for all zones.\n> \n> Add a replacement characters to the user defined list. The character data must be\n> the same as for a single character in the font definition file. If a character is\n> specified with a code the same as an existing character the existing data will be\n> substituted for the new data. A character code of 0 ('\\0') is illegal as this\n> denotes the end of string character for C++ and cannot be used in an actual string.\n> \n> The library does not copy the data definition but only retains a pointer to the data,\n> so any changes to the data storage in the calling program will be reflected into the\n> library. The data must also remain in scope while it is being used.\n> \n> \\param code\tASCII code for the character data.\n> \\param data\tpointer to the character data.\n> \\return No return value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "addChar",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\ninline bool addChar(uint8_t z, uint8_t code, uint8_t *data) { return(z < _numZones ? _Z[z].addChar(code, data) : false); };\n```\n> *\n> Add a user defined character to the replacement specified zone.\n> \n> See the comments for the 'all zones' variant of this method\n> \n> \\param z\t\tzone specified\n> \\param code\tASCII code for the character data.\n> \\param data\tpointer to the character data.\n> \\return true of the character was inserted in the substitution list.\n>    \n",
    "lang": "c"
  },
  {
    "name": "delChar",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\nvoid delChar(uint8_t code) { for (uint8_t i=0; i<_numZones; i++) _Z[i].delChar(code); };\n```\n> *\n> Delete a user defined character to the replacement list for all zones.\n> \n> Delete a reference to a replacement character in the user defined list.\n> \n> \\param code\tASCII code for the character data.\n> \\return No return value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "delChar",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\ninline bool delChar(uint8_t z, uint8_t code) { return(z < _numZones ? _Z[z].delChar(code) : false); };\n```\n> *\n> Delete a user defined character to the replacement list for the specified zone.\n> \n> See the comments for the 'all zones' variant of this method.\n> \n> \\param z\t\tzone specified\n> \\param code\tASCII code for the character data.\n> \\return true of the character was found in the substitution list.\n>    \n",
    "lang": "c"
  },
  {
    "name": "setFont",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\nvoid setFont(MD_MAX72XX::fontType_t *fontDef) { for (uint8_t i=0; i<_numZones; i++) _Z[i].setZoneFont(fontDef); };\n```\n> *\n> Set the display font for all zones.\n> \n> Set the display font to a user defined font table. This can be created using the\n> MD_MAX72xx font builder (refer to documentation for the tool and the MD_MAX72xx library).\n> Passing nullptr resets to the library default font.\n> \n> \\param fontDef\tPointer to the font definition to be used.\n> \\return No return value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "setFont",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\ninline void setFont(uint8_t z, MD_MAX72XX::fontType_t *fontDef) { if (z < _numZones) _Z[z].setZoneFont(fontDef); };\n```\n> *\n> Set the display font for a specific zone.\n> \n> Set the display font to a user defined font table. This can be created using the\n> MD_MAX72xx font builder (refer to documentation for the tool and the MD_MAX72xx library).\n> Passing nullptr resets to the library default font.\n> \n> \\param z\t\tspecified zone.\n> \\param fontDef\tPointer to the font definition to be used.\n> \\return No return value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "write",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\nvirtual size_t write(uint8_t c) { char sz[2]; sz[0] = c; sz[1] = '\\0'; write(sz); return(1); }\n```\n> *\n> Write a single character to the output display\n> \n> Display a character when given the ASCII code for it. The character is\n> converted to a string and the string printing function invoked.\n> The LED display is designed for string based output, so it does not make much\n> sense to do this. Creating the short string is a consistent way to way to handle\n> single the character.\n> \n> \\param c\tASCII code for the character to write.\n> \\return the number of characters written.\n>   \n",
    "lang": "c"
  },
  {
    "name": "write",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\nvirtual size_t write(const char *str);\n```\n> *\n> Write a nul terminated string to the output display.\n> \n> Display a nul terminated string when given a pointer to the char array.\n> Invokes an animation using PA_PRINT with all other settings (alignment,\n> speed, etc) taken from current defaults.\n> This method also invokes the animation for the print and returns when that has\n> finished, so it blocks while the printing is happening, which should be at least \n> one iteration of the wait loop.\n> \n> \\param str\tPointer to the nul terminated char array.\n> \\return the number of characters written.\n>   \n",
    "lang": "c"
  },
  {
    "name": "write",
    "file": "[MD_Parola.h](https://github.com/mongoose-os-libs/arduino-md-parola/blob/master/include/MD_Parola.h)",
    "doc": "\n```c\nvirtual size_t write(const uint8_t *buffer, size_t size);\n```\n> *\n> Write a character buffer to the output display.\n> \n> Display a non-nul terminated string given a pointer to the buffer and\n> the size of the buffer. The buffer is turned into a nul terminated string\n> and the simple write() method is invoked. Memory is allocated and freed\n> in this method to copy the string.\n> \n> \\param buffer\tPointer to the data buffer.\n> \\param size The number of bytes to write.\n> \\return the number of bytes written.\n>   \n",
    "lang": "c"
  },
  {
    "name": "reset",
    "file": "[OneWire.h](https://github.com/mongoose-os-libs/arduino-onewire/blob/master/include/OneWire.h)",
    "doc": "\n```c\nuint8_t reset(void);\n```\n> Perform a 1-Wire reset cycle. Returns 1 if a device responds\n> with a presence pulse.  Returns 0 if there is no device or the\n> bus is shorted or otherwise held low for more than 250uS\n",
    "lang": "c"
  },
  {
    "name": "select",
    "file": "[OneWire.h](https://github.com/mongoose-os-libs/arduino-onewire/blob/master/include/OneWire.h)",
    "doc": "\n```c\nvoid select(const uint8_t rom[8]);\n```\n> Issue a 1-Wire rom select command, you do the reset first.\n",
    "lang": "c"
  },
  {
    "name": "skip",
    "file": "[OneWire.h](https://github.com/mongoose-os-libs/arduino-onewire/blob/master/include/OneWire.h)",
    "doc": "\n```c\nvoid skip(void);\n```\n> Issue a 1-Wire rom skip command, to address all on bus.\n",
    "lang": "c"
  },
  {
    "name": "write",
    "file": "[OneWire.h](https://github.com/mongoose-os-libs/arduino-onewire/blob/master/include/OneWire.h)",
    "doc": "\n```c\nvoid write(uint8_t v, uint8_t power = 0);\n```\n> Write a byte. If 'power' is one then the wire is held high at\n> the end for parasitically powered devices. You are responsible\n> for eventually depowering it by calling depower() or doing\n> another read or write.\n",
    "lang": "c"
  },
  {
    "name": "read",
    "file": "[OneWire.h](https://github.com/mongoose-os-libs/arduino-onewire/blob/master/include/OneWire.h)",
    "doc": "\n```c\nuint8_t read(void);\n```\n> Read a byte.\n",
    "lang": "c"
  },
  {
    "name": "write_bit",
    "file": "[OneWire.h](https://github.com/mongoose-os-libs/arduino-onewire/blob/master/include/OneWire.h)",
    "doc": "\n```c\nvoid write_bit(uint8_t v);\n```\n> Write a bit. The bus is always left powered at the end, see\n> note in write() about that.\n",
    "lang": "c"
  },
  {
    "name": "read_bit",
    "file": "[OneWire.h](https://github.com/mongoose-os-libs/arduino-onewire/blob/master/include/OneWire.h)",
    "doc": "\n```c\nuint8_t read_bit(void);\n```\n> Read a bit.\n",
    "lang": "c"
  },
  {
    "name": "depower",
    "file": "[OneWire.h](https://github.com/mongoose-os-libs/arduino-onewire/blob/master/include/OneWire.h)",
    "doc": "\n```c\nvoid depower(void);\n```\n> Stop forcing power onto the bus. You only need to do this if\n> you used the 'power' flag to write() or used a write_bit() call\n> and aren't about to do another read or write. You would rather\n> not leave this powered if you don't have to, just in case\n> someone shorts your bus.\n",
    "lang": "c"
  },
  {
    "name": "reset_search",
    "file": "[OneWire.h](https://github.com/mongoose-os-libs/arduino-onewire/blob/master/include/OneWire.h)",
    "doc": "\n```c\nvoid reset_search();\n```\n> Clear the search state so that if will start from the beginning again.\n",
    "lang": "c"
  },
  {
    "name": "target_search",
    "file": "[OneWire.h](https://github.com/mongoose-os-libs/arduino-onewire/blob/master/include/OneWire.h)",
    "doc": "\n```c\nvoid target_search(uint8_t family_code);\n```\n> Setup the search to find the device type 'family_code' on the next call\n> to search(*newAddr) if it is present.\n",
    "lang": "c"
  },
  {
    "name": "search",
    "file": "[OneWire.h](https://github.com/mongoose-os-libs/arduino-onewire/blob/master/include/OneWire.h)",
    "doc": "\n```c\nuint8_t search(uint8_t *newAddr, bool search_mode = true);\n```\n> Look for the next device. Returns 1 if a new address has been\n> returned. A zero might mean that the bus is shorted, there are\n> no devices, or you have already retrieved all of them.  It\n> might be a good idea to check the CRC to make sure you didn't\n> get garbage.  The order is deterministic. You will always get\n> the same devices in the same order.\n",
    "lang": "c"
  },
  {
    "name": "crc8",
    "file": "[OneWire.h](https://github.com/mongoose-os-libs/arduino-onewire/blob/master/include/OneWire.h)",
    "doc": "\n```c\nstatic uint8_t crc8(const uint8_t *addr, uint8_t len);\n  \n private:\n  struct mgos_onewire *ow_;  // The mgos_onewire handle\n};\n```\n> Compute a Dallas Semiconductor 8 bit CRC, these are used in the\n> ROM and scratchpad registers.\n",
    "lang": "c"
  },
  {
    "name": "OneWire.create()",
    "file": "[api_arduino_onewire.js](https://github.com/mongoose-os-libs/arduino-onewire/blob/master/mjs_fs/api_arduino_onewire.js)",
    "doc": "\n```javascript\nOneWire.create()\n```\nCreate a OneWire object instance. Return value: an object with the methods\ndescribed below.\n",
    "lang": "js"
  },
  {
    "name": "myOW.close()",
    "file": "[api_arduino_onewire.js](https://github.com/mongoose-os-libs/arduino-onewire/blob/master/mjs_fs/api_arduino_onewire.js)",
    "doc": "\n```javascript\nmyOW.close()\n```\nClose OneWire handle. Return value: none.\n",
    "lang": "js"
  },
  {
    "name": "myOW.reset()",
    "file": "[api_arduino_onewire.js](https://github.com/mongoose-os-libs/arduino-onewire/blob/master/mjs_fs/api_arduino_onewire.js)",
    "doc": "\n```javascript\nmyOW.reset()\n```\nReset the 1-wire bus. Usually this is needed before communicating with\nany device.\n",
    "lang": "js"
  },
  {
    "name": "myOW.select(addr)",
    "file": "[api_arduino_onewire.js](https://github.com/mongoose-os-libs/arduino-onewire/blob/master/mjs_fs/api_arduino_onewire.js)",
    "doc": "\n```javascript\nmyOW.select(addr)\n```\nSelect a device based on its address `addr`, which is a 8-byte string.\nAfter a reset, this is needed to choose which device you will use, and\nthen all communication will be with that device, until another reset.\nExample:\n```javascript\nmyOW.select(\"\\x28\\xff\\x2b\\x45\\x4c\\x04\\x00\\x10\");\n```\n",
    "lang": "js"
  },
  {
    "name": "myOW.skip()",
    "file": "[api_arduino_onewire.js](https://github.com/mongoose-os-libs/arduino-onewire/blob/master/mjs_fs/api_arduino_onewire.js)",
    "doc": "\n```javascript\nmyOW.skip()\n```\nSkip the device selection. This only works if you have a single device,\nbut you can avoid searching and use this to immediately access your\ndevice.\n",
    "lang": "js"
  },
  {
    "name": "myOW.write(v)",
    "file": "[api_arduino_onewire.js](https://github.com/mongoose-os-libs/arduino-onewire/blob/master/mjs_fs/api_arduino_onewire.js)",
    "doc": "\n```javascript\nmyOW.write(v)\n```\nWrite a byte to the onewire bus. Example:\n```javascript\n// Write 0x12 to the onewire bus\nmyOW.write(0x12);\n```\n",
    "lang": "js"
  },
  {
    "name": "myOW.write_bytes(buf, len)",
    "file": "[api_arduino_onewire.js](https://github.com/mongoose-os-libs/arduino-onewire/blob/master/mjs_fs/api_arduino_onewire.js)",
    "doc": "\n```javascript\nmyOW.write_bytes(buf, len)\n```\nWrite first `len` bytes of the string `buf`. Example:\n```javascript\n// Write [0x55, 0x66, 0x77] to the onewire bus\nmyOW.write_bytes(\"\\x55\\x66\\x77\", 3);\n```\n",
    "lang": "js"
  },
  {
    "name": "myOW.read()",
    "file": "[api_arduino_onewire.js](https://github.com/mongoose-os-libs/arduino-onewire/blob/master/mjs_fs/api_arduino_onewire.js)",
    "doc": "\n```javascript\nmyOW.read()\n```\nRead a byte from the onewire bus. Example:\n```javascript\nlet b = myOW.read();\nprint('read:', b);\n```\n",
    "lang": "js"
  },
  {
    "name": "myOW.read_bytes(buf, len)",
    "file": "[api_arduino_onewire.js](https://github.com/mongoose-os-libs/arduino-onewire/blob/master/mjs_fs/api_arduino_onewire.js)",
    "doc": "\n```javascript\nmyOW.read_bytes(buf, len)\n```\nRead multiple bytes from the onewire bus. The given buffer should\nbe large enough to fit the data; otherwise it will result in memory\ncorruption and thus undefined behavior.\nReturn value: none.\nExample:\n```javascript\nlet buf = \"          \";\nmyOW.read_bytes(buf, 10);\nprint('read:', buf);\n```\n",
    "lang": "js"
  },
  {
    "name": "myOW.write_bit(v)",
    "file": "[api_arduino_onewire.js](https://github.com/mongoose-os-libs/arduino-onewire/blob/master/mjs_fs/api_arduino_onewire.js)",
    "doc": "\n```javascript\nmyOW.write_bit(v)\n```\nWrite a single bit to the onewire bus. Given `v` should be a number:\neither 0 or 1.\n",
    "lang": "js"
  },
  {
    "name": "myOW.read_bit()",
    "file": "[api_arduino_onewire.js](https://github.com/mongoose-os-libs/arduino-onewire/blob/master/mjs_fs/api_arduino_onewire.js)",
    "doc": "\n```javascript\nmyOW.read_bit()\n```\nRead a single bit from the onewire bus. Returned value is either 0 or 1.\n",
    "lang": "js"
  },
  {
    "name": "myOW.depower()",
    "file": "[api_arduino_onewire.js](https://github.com/mongoose-os-libs/arduino-onewire/blob/master/mjs_fs/api_arduino_onewire.js)",
    "doc": "\n```javascript\nmyOW.depower()\n```\nNot implemented yet.\n",
    "lang": "js"
  },
  {
    "name": "myOW.search(addr, mode)",
    "file": "[api_arduino_onewire.js](https://github.com/mongoose-os-libs/arduino-onewire/blob/master/mjs_fs/api_arduino_onewire.js)",
    "doc": "\n```javascript\nmyOW.search(addr, mode)\n```\nSearch for the next device. The given `addr` should be an string\ncontaining least 8 bytes (any bytes). If a device is found, `addr` is\nfilled with the device's address and 1 is returned. If no more\ndevices are found, 0 is returned.\n`mode` is an integer: 0 means normal search, 1 means conditional search.\nExample:\n```javascript\nlet addr = \"        \";\nlet res = myOW.search(addr, 0);\nif (res === 1) {\n  print(\"Found:\", addr);\n} else {\n  print(\"Not found\");\n}\n```\n",
    "lang": "js"
  },
  {
    "name": "myOW.reset_search()",
    "file": "[api_arduino_onewire.js](https://github.com/mongoose-os-libs/arduino-onewire/blob/master/mjs_fs/api_arduino_onewire.js)",
    "doc": "\n```javascript\nmyOW.reset_search()\n```\nReset a search. Next use of `myOW.search(....)` will begin at the first\ndevice.\n",
    "lang": "js"
  },
  {
    "name": "myOW.target_search(fc)",
    "file": "[api_arduino_onewire.js](https://github.com/mongoose-os-libs/arduino-onewire/blob/master/mjs_fs/api_arduino_onewire.js)",
    "doc": "\n```javascript\nmyOW.target_search(fc)\n```\nSetup the search to find the device type 'fc' (family code) on the next\ncall to `myOW.search()` if it is present.\n\nIf no devices of the desired family are currently on the bus, then\ndevice of some another type will be found by `search()`.\n",
    "lang": "js"
  },
  {
    "name": "myOW.crc8(buf, len)",
    "file": "[api_arduino_onewire.js](https://github.com/mongoose-os-libs/arduino-onewire/blob/master/mjs_fs/api_arduino_onewire.js)",
    "doc": "\n```javascript\nmyOW.crc8(buf, len)\n```\nCalculate crc8 for the first `len` bytes of a string `buf`.\nExample:\n```javascript\n// Calculate crc8 of the buffer\nlet s = \"foobar\";\nlet crc = myOW.crc8(s, 6);\nprint(\"crc:\", crc);\n```\n",
    "lang": "js"
  },
  {
    "name": "myOW.delay(t)",
    "file": "[api_arduino_onewire.js](https://github.com/mongoose-os-libs/arduino-onewire/blob/master/mjs_fs/api_arduino_onewire.js)",
    "doc": "\n```javascript\nmyOW.delay(t)\n```\nDelay `t` milliseconds.\n",
    "lang": "js"
  },
  {
    "name": "begin",
    "file": "[SPI.h](https://github.com/mongoose-os-libs/arduino-spi/blob/master/include/SPI.h)",
    "doc": "\n```c\nvoid begin();\n  void end();\n```\n>  Arduino interface \n",
    "lang": "c"
  },
  {
    "name": "setBitOrder",
    "file": "[SPI.h](https://github.com/mongoose-os-libs/arduino-spi/blob/master/include/SPI.h)",
    "doc": "\n```c\nvoid setBitOrder(uint8_t bitOrder);\n  void setDataMode(uint8_t dataMode);\n  void setFrequency(uint32_t freq);\n  // void setClockDivider(uint32_t clockDiv);\n```\n> void setHwCs(bool use);\n",
    "lang": "c"
  },
  {
    "name": "write",
    "file": "[SPI.h](https://github.com/mongoose-os-libs/arduino-spi/blob/master/include/SPI.h)",
    "doc": "\n```c\nvoid write(uint8_t data);\n  void write16(uint16_t data);\n  void write32(uint32_t data);\n  void writeBytes(const uint8_t *data, uint32_t size);\n```\n> void transferBits(uint32_t data, uint32_t * out, uint8_t bits);\n",
    "lang": "c"
  },
  {
    "name": "mbedtls_atca_is_available",
    "file": "[mgos_atca.h](https://github.com/mongoose-os-libs/atca/blob/master/include/mgos_atca.h)",
    "doc": "\n```c\nint mbedtls_atca_is_available(void);\n```\n>  Invoked from mbedTLS during ECDH phase of the handshake. \n",
    "lang": "c"
  },
  {
    "name": "aws_gg_net_ready",
    "file": "[mgos_aws_greengrass.h](https://github.com/mongoose-os-libs/aws/blob/master/include/mgos_aws_greengrass.h)",
    "doc": "\n```c\nvoid aws_gg_net_ready(int ev, void *evd, void *arg);\n```\n>  Network configuration hook handler for the AWS GreenGrass. \n",
    "lang": "c"
  },
  {
    "name": "aws_gg_reconnect",
    "file": "[mgos_aws_greengrass.h](https://github.com/mongoose-os-libs/aws/blob/master/include/mgos_aws_greengrass.h)",
    "doc": "\n```c\nvoid aws_gg_reconnect(void);\n```\n>  Reconnect to GreenGrass. \n",
    "lang": "c"
  },
  {
    "name": "AWS.isConnected()",
    "file": "[api_aws.js](https://github.com/mongoose-os-libs/aws/blob/master/mjs_fs/api_aws.js)",
    "doc": "\n```javascript\nAWS.isConnected()\n```\nReturn value: true if AWS connection is up, false otherwise.\n",
    "lang": "js"
  },
  {
    "name": "AWS.Shadow.setStateHandler(callback, userdata)",
    "file": "[api_aws.js](https://github.com/mongoose-os-libs/aws/blob/master/mjs_fs/api_aws.js)",
    "doc": "\n```javascript\nAWS.Shadow.setStateHandler(callback, userdata)\n```\n\nSet AWS shadow state handler callback.\n\nWhen AWS shadow state changes, the callback is\ncalled with the following arguments: `(userdata, event, reported,\ndesired, reported_metadata, desired_metadata)`,\nwhere `userdata` is the userdata given to `setStateHandler`,\n`event` is one of the following: `AWS.Shadow.CONNECTED`,\n`AWS.Shadow.GET_ACCEPTED`,\n`AWS.Shadow.GET_REJECTED`, `AWS.Shadow.UPDATE_ACCEPTED`,\n`AWS.Shadow.UPDATE_REJECTED`, `AWS.Shadow.UPDATE_DELTA`.\n`reported` is previously reported state object (if any), and `desired`\nis the desired state (if present).\n\nExample:\n```javascript\nlet state = { on: false, counter: 0 };  // device state: shadow metadata\n\n// Upon startup, report current actual state, \"reported\"\n// When cloud sends us a command to update state (\"desired\"), do it\nAWS.Shadow.setStateHandler(function(data, event, reported, desired, reported_metadata, desired_metadata) {\n  if (event === AWS.Shadow.CONNECTED) {\n    AWS.Shadow.update(0, state);  // Report device state\n  } else if (event === AWS.Shadow.UPDATE_DELTA) {\n    for (let key in state) {\n      if (desired[key] !== undefined) state[key] = desired[key];\n    }\n    AWS.Shadow.update(0, state);  // Report device state\n  }\n  print(JSON.stringify(reported), JSON.stringify(desired));\n}, null);\n```\n",
    "lang": "js"
  },
  {
    "name": "AWS.Shadow.get()",
    "file": "[api_aws.js](https://github.com/mongoose-os-libs/aws/blob/master/mjs_fs/api_aws.js)",
    "doc": "\n```javascript\nAWS.Shadow.get()\n```\n\nRequest shadow state. The event handler (see\n`AWS.Shadow.setStateHandler()`) will receive a `GET_ACCEPTED` event.\nReturns true in case of success, false otherwise.\n",
    "lang": "js"
  },
  {
    "name": "AWS.Shadow.getVersion();",
    "file": "[api_aws.js](https://github.com/mongoose-os-libs/aws/blob/master/mjs_fs/api_aws.js)",
    "doc": "\n```javascript\nAWS.Shadow.getVersion();\n```\nReturn last shadow state version (a number).\n",
    "lang": "js"
  },
  {
    "name": "AWS.Shadow.update(version, state);",
    "file": "[api_aws.js](https://github.com/mongoose-os-libs/aws/blob/master/mjs_fs/api_aws.js)",
    "doc": "\n```javascript\nAWS.Shadow.update(version, state);\n```\n\nUpdate AWS shadow state.\n\nState should be an object with \"reported\" and/or \"desired\" keys.\n\nResponse will arrive via `UPDATE_ACCEPTED` or `UPDATE_REJECTED` events.\nIf you want the update to be aplied only if a particular version is\ncurrent, specify the version. Otherwise set it to 0 to apply to any\nversion.\n\nExample:\n```javascript\n// On a button press, update press counter via the shadow\nlet buttonPin = 0;\nGPIO.set_button_handler(buttonPin, GPIO.PULL_UP, GPIO.INT_EDGE_NEG, 200, function() {\n  AWS.Shadow.update(0, {desired: {on: state.on, counter: state.counter + 1}});\n}, null);\n```\n",
    "lang": "js"
  },
  {
    "name": "mgos_azure_send_d2c_msg",
    "file": "[mgos_azure.h](https://github.com/mongoose-os-libs/azure/blob/master/include/mgos_azure.h)",
    "doc": "\n```c\nbool mgos_azure_send_d2c_msg(const struct mg_str props,\n                             const struct mg_str body);\n```\n> \n> Send a Device to Cloud message.\n> If present, the properties string must be URL-encoded.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_azure_send_d2c_msgf",
    "file": "[mgos_azure.h](https://github.com/mongoose-os-libs/azure/blob/master/include/mgos_azure.h)",
    "doc": "\n```c\nbool mgos_azure_send_d2c_msgf(const struct mg_str props, const char *json_fmt,\n                              ...);\n```\n>  A variant of mgos_azure_send_d2c_msg that formats a JSON message. \n",
    "lang": "c"
  },
  {
    "name": "mgos_azure_send_d2c_msgp",
    "file": "[mgos_azure.h](https://github.com/mongoose-os-libs/azure/blob/master/include/mgos_azure.h)",
    "doc": "\n```c\nbool mgos_azure_send_d2c_msgp(const struct mg_str *props,\n                              const struct mg_str *body);\n```\n>  A variant of mgos_azure_send_d2c_msg that takes pointers, for easy FFI. \n",
    "lang": "c"
  },
  {
    "name": "mgos_azure_get_host_name",
    "file": "[mgos_azure.h](https://github.com/mongoose-os-libs/azure/blob/master/include/mgos_azure.h)",
    "doc": "\n```c\nstruct mg_str mgos_azure_get_host_name(void);\n```\n>  Returns host name of the Azure hub \n",
    "lang": "c"
  },
  {
    "name": "mgos_azure_get_device_id",
    "file": "[mgos_azure.h](https://github.com/mongoose-os-libs/azure/blob/master/include/mgos_azure.h)",
    "doc": "\n```c\nstruct mg_str mgos_azure_get_device_id(void);\n```\n>  Returns Azure device ID \n",
    "lang": "c"
  },
  {
    "name": "mgos_azure_is_connected",
    "file": "[mgos_azure.h](https://github.com/mongoose-os-libs/azure/blob/master/include/mgos_azure.h)",
    "doc": "\n```c\nbool mgos_azure_is_connected(void);\n```\n>  Returns true if Azure connection is up, false otherwise. \n",
    "lang": "c"
  },
  {
    "name": "mgos_azure_dm_response",
    "file": "[mgos_azure.h](https://github.com/mongoose-os-libs/azure/blob/master/include/mgos_azure.h)",
    "doc": "\n```c\nbool mgos_azure_dm_response(struct mg_str id, int status,\n                            const struct mg_str *resp);\n```\n>  Respond to a Direct Method call. \n",
    "lang": "c"
  },
  {
    "name": "mgos_azure_dm_responsef",
    "file": "[mgos_azure.h](https://github.com/mongoose-os-libs/azure/blob/master/include/mgos_azure.h)",
    "doc": "\n```c\nbool mgos_azure_dm_responsef(struct mg_str id, int status, const char *json_fmt,\n                             ...);\n```\n>  Respond to a Direct Method call with a JSON message. \n",
    "lang": "c"
  },
  {
    "name": "Azure.isConnected()",
    "file": "[api_azure.js](https://github.com/mongoose-os-libs/azure/blob/master/mjs_fs/api_azure.js)",
    "doc": "\n```javascript\nAzure.isConnected()\n```\nReturn value: true if Azure connection is up, false otherwise.\n",
    "lang": "js"
  },
  {
    "name": "Azure.sendD2CMsg(props, body)",
    "file": "[api_azure.js](https://github.com/mongoose-os-libs/azure/blob/master/mjs_fs/api_azure.js)",
    "doc": "\n```javascript\nAzure.sendD2CMsg(props, body)\n```\nSend a Device to Cloud message. `props`, if specified, must be URL-encoded.\n",
    "lang": "js"
  },
  {
    "name": "_read",
    "file": "[mgos_barometer.h](https://github.com/mongoose-os-libs/barometer/blob/master/include/mgos_barometer.h)",
    "doc": "\n```c\nuint32_t read;                 // calls to _read()\n  uint32_t read_success;         // successful _read()\n  uint32_t read_success_cached;  // calls to _read() which were cached\n  // Note: read_errors := read - read_success - read_success_cached\n  double   read_success_usecs;   // time spent in successful uncached _read()\n};\n```\n> value of mg_time() upon last call to _read()\n",
    "lang": "c"
  },
  {
    "name": "mgos_barometer_set_cache_ttl",
    "file": "[mgos_barometer.h](https://github.com/mongoose-os-libs/barometer/blob/master/include/mgos_barometer.h)",
    "doc": "\n```c\nbool mgos_barometer_set_cache_ttl(struct mgos_barometer *sensor, uint16_t msecs);\n```\n>  Set cache TTL -- will limit reads and return cached data. Set msecs=0 to turn off \n",
    "lang": "c"
  },
  {
    "name": "mgos_barometer_read",
    "file": "[mgos_barometer.h](https://github.com/mongoose-os-libs/barometer/blob/master/include/mgos_barometer.h)",
    "doc": "\n```c\nbool mgos_barometer_read(struct mgos_barometer *sensor);\n```\n>  Read all available sensor data from the barometer \n",
    "lang": "c"
  },
  {
    "name": "mgos_barometer_get_pressure",
    "file": "[mgos_barometer.h](https://github.com/mongoose-os-libs/barometer/blob/master/include/mgos_barometer.h)",
    "doc": "\n```c\nbool mgos_barometer_get_pressure(struct mgos_barometer *sensor, float *p);\n```\n>  Return barometer data in units of Pascals \n",
    "lang": "c"
  },
  {
    "name": "mgos_barometer_get_temperature",
    "file": "[mgos_barometer.h](https://github.com/mongoose-os-libs/barometer/blob/master/include/mgos_barometer.h)",
    "doc": "\n```c\nbool mgos_barometer_get_temperature(struct mgos_barometer *sensor, float *t);\n```\n>  Return temperature data in units of Celsius \n",
    "lang": "c"
  },
  {
    "name": "mgos_barometer_get_humidity",
    "file": "[mgos_barometer.h](https://github.com/mongoose-os-libs/barometer/blob/master/include/mgos_barometer.h)",
    "doc": "\n```c\nbool mgos_barometer_get_humidity(struct mgos_barometer *sensor, float *h);\n```\n>  Return humidity data in units of % Relative Humidity \n",
    "lang": "c"
  },
  {
    "name": "mgos_barometer_get_name",
    "file": "[mgos_barometer.h](https://github.com/mongoose-os-libs/barometer/blob/master/include/mgos_barometer.h)",
    "doc": "\n```c\nconst char *mgos_barometer_get_name(struct mgos_barometer *sensor);\n```\n>  String representation of the barometer type, guaranteed to be 10 characters or less. \n",
    "lang": "c"
  },
  {
    "name": "mgos_barometer_get_stats",
    "file": "[mgos_barometer.h](https://github.com/mongoose-os-libs/barometer/blob/master/include/mgos_barometer.h)",
    "doc": "\n```c\nbool mgos_barometer_get_stats(struct mgos_barometer *sensor, struct mgos_barometer_stats *stats);\n```\n> \n> Return statistics on the sensor.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_barometer_init",
    "file": "[mgos_barometer.h](https://github.com/mongoose-os-libs/barometer/blob/master/include/mgos_barometer.h)",
    "doc": "\n```c\nbool mgos_barometer_init(void);\n```\n> \n> Initialization function for MGOS -- currently a noop.\n>  \n",
    "lang": "c"
  },
  {
    "name": "bh1730_init",
    "file": "[bh1730.h](https://github.com/mongoose-os-libs/bh1730/blob/master/include/bh1730.h)",
    "doc": "\n```c\nbh1730_t *bh1730_init(int addr);\n```\n> \n> Create and return a BH1730 instance; `addr` is an I2C address of the BH1730\n> sensor.\n>  \n",
    "lang": "c"
  },
  {
    "name": "bh1730_read_lux",
    "file": "[bh1730.h](https://github.com/mongoose-os-libs/bh1730/blob/master/include/bh1730.h)",
    "doc": "\n```c\nfloat bh1730_read_lux(bh1730_t *d);\n```\n> \n> Return the ambient light level in lux, or -1 in case of a failure.\n>  \n",
    "lang": "c"
  },
  {
    "name": "BH1730.create(addr)",
    "file": "[api_bh1730.js](https://github.com/mongoose-os-libs/bh1730/blob/master/mjs_fs/api_bh1730.js)",
    "doc": "\n```javascript\nBH1730.create(addr)\n```\nCreate a BH1730 instance: an object with the methods described below.\n`addr` is an i2c address of the BH1730 sensor.\n",
    "lang": "js"
  },
  {
    "name": "myBH.read_lux()",
    "file": "[api_bh1730.js](https://github.com/mongoose-os-libs/bh1730/blob/master/mjs_fs/api_bh1730.js)",
    "doc": "\n```javascript\nmyBH.read_lux()\n```\nReturn the ambient light level in lux, or -1 in case of a failure.\n",
    "lang": "js"
  },
  {
    "name": "(*blynk_handler_t)",
    "file": "[mgos_blynk.h](https://github.com/mongoose-os-libs/blynk/blob/master/include/mgos_blynk.h)",
    "doc": "\n```c\ntypedef void (*blynk_handler_t)(struct mg_connection *, const char *cmd,\n                                int pin, int val, int id, void *user_data);\n```\n>  Blynk event handler signature. \n",
    "lang": "c"
  },
  {
    "name": "blynk_set_handler",
    "file": "[mgos_blynk.h](https://github.com/mongoose-os-libs/blynk/blob/master/include/mgos_blynk.h)",
    "doc": "\n```c\nvoid blynk_set_handler(blynk_handler_t func, void *user_data);\n```\n>  Set Blynk event handler. \n",
    "lang": "c"
  },
  {
    "name": "blynk_send",
    "file": "[mgos_blynk.h](https://github.com/mongoose-os-libs/blynk/blob/master/include/mgos_blynk.h)",
    "doc": "\n```c\nvoid blynk_send(struct mg_connection *c, uint8_t type, uint16_t id,\n                const void *data, uint16_t len);\n```\n>  Send data to the Blynk server. `data`, `len` holds a message to send. \n",
    "lang": "c"
  },
  {
    "name": "blynk_printf",
    "file": "[mgos_blynk.h](https://github.com/mongoose-os-libs/blynk/blob/master/include/mgos_blynk.h)",
    "doc": "\n```c\nvoid blynk_printf(struct mg_connection *c, uint8_t type, uint16_t id,\n                  const char *fmt, ...);\n```\n>  Same as as `blynk_send()`, formats message using `printf()` semantics. \n",
    "lang": "c"
  },
  {
    "name": "blynk_virtual_write",
    "file": "[mgos_blynk.h](https://github.com/mongoose-os-libs/blynk/blob/master/include/mgos_blynk.h)",
    "doc": "\n```c\nvoid blynk_virtual_write(struct mg_connection *c, int pin, float val, int id);\n```\n>  Send a virtual write command \n",
    "lang": "c"
  },
  {
    "name": "Blynk.send(conn, type, msg, id)",
    "file": "[api_blynk.js](https://github.com/mongoose-os-libs/blynk/blob/master/mjs_fs/api_blynk.js)",
    "doc": "\n```javascript\nBlynk.send(conn, type, msg, id)\n```\nSend raw message to Blynk server.\n\n`conn` is a network connection which is passed to the handler registered\nwith `Blynk.setHandler`. `type` is one of the following:\n\n- `Blynk.TYPE_RESPONSE`\n- `Blynk.TYPE_LOGIN`\n- `Blynk.TYPE_PING`\n- `Blynk.TYPE_HARDWARE`\n\n`msg` is a string with the data to send. `id` is the internal blynk\nmessage id; if undefined it will be autogenerated.\n\nReturn value: none.\nExample:\n```javascript\n// Send \"virtual write\" command manually: write \"1\" to pin \"16\"\nBlynk.send(conn, Blynk.TYPE_HARDWARE, 'vw\\x0016\\x001');\n```\n",
    "lang": "js"
  },
  {
    "name": "Blynk.virtualWrite(conn, pin, val, id)",
    "file": "[api_blynk.js](https://github.com/mongoose-os-libs/blynk/blob/master/mjs_fs/api_blynk.js)",
    "doc": "\n```javascript\nBlynk.virtualWrite(conn, pin, val, id)\n```\nWrite to the virtual pin. If id is undefined, it will be autogenerated.\nThis is a helper function that uses `Blynk.send()`.\nReturn value: none.\nExample:\n```javascript\n// Send \"virtual write\" command: write \"1\" to pin \"16\"\nBlynk.virtualWrite(conn, 16, 1);\n```\n",
    "lang": "js"
  },
  {
    "name": "Blynk.setHandler(handler, userdata)",
    "file": "[api_blynk.js](https://github.com/mongoose-os-libs/blynk/blob/master/mjs_fs/api_blynk.js)",
    "doc": "\n```javascript\nBlynk.setHandler(handler, userdata)\n```\nSet handler for the virtual pin reads / writes.\n\nExample:\n```javascript\nBlynk.setHandler(function(conn, cmd, pin, val, id) {\n  print(cmd, pin, val);\n}, null);\n```\n",
    "lang": "js"
  },
  {
    "name": "BM222.init(bus, addr)",
    "file": "[api_bm222.js](https://github.com/mongoose-os-libs/bm222/blob/master/mjs_fs/api_bm222.js)",
    "doc": "\n```javascript\nBM222.init(bus, addr)\n```\nInitialize BM222 sensor on a given I2C `bus` and `addr`.\nReturns true on success, false otherwise.\n",
    "lang": "js"
  },
  {
    "name": "BM222.read()",
    "file": "[api_bm222.js](https://github.com/mongoose-os-libs/bm222/blob/master/mjs_fs/api_bm222.js)",
    "doc": "\n```javascript\nBM222.read()\n```\nRead sensor values given I2C `bus` and `addr`.\nIn case of success, returns array of 3 integers: x, y, z.\nOtherwise returns `null`.\n",
    "lang": "js"
  },
  {
    "name": "BME280",
    "file": "[BME280.h](https://github.com/mongoose-os-libs/bme280/blob/master/include/BME280.h)",
    "doc": "\n```c\nBME280(uint8_t addr, bool spi = false)\n  : _bme(spi ? mgos_bme280_spi_create() : mgos_bme280_i2c_create(addr)) {\n  }\n```\n> \n> Creates the BME280 object for the device with `addr` address\n>    \n",
    "lang": "c"
  },
  {
    "name": "~BME280",
    "file": "[BME280.h](https://github.com/mongoose-os-libs/bme280/blob/master/include/BME280.h)",
    "doc": "\n```c\n~BME280() {\n    mgos_bme280_delete(_bme);\n  }\n```\n> \n> Deletes the object and frees resources.\n>    \n",
    "lang": "c"
  },
  {
    "name": "read",
    "file": "[BME280.h](https://github.com/mongoose-os-libs/bme280/blob/master/include/BME280.h)",
    "doc": "\n```c\nint8_t read(struct mgos_bme280_data& data) {\n    return mgos_bme280_read(_bme, &data);\n  }\n```\n> \n> Reads the temperature, pressure and humidity in the provided `data` structure.\n> If the device is BMP280, the humidity will be 0.\n>    \n",
    "lang": "c"
  },
  {
    "name": "readTemperature",
    "file": "[BME280.h](https://github.com/mongoose-os-libs/bme280/blob/master/include/BME280.h)",
    "doc": "\n```c\ndouble readTemperature() {\n    return mgos_bme280_read_temperature(_bme);\n  }\n```\n> \n> Reads the temperature.\n> Returns MGOS_BME280_ERROR if error.\n>    \n",
    "lang": "c"
  },
  {
    "name": "readPressure",
    "file": "[BME280.h](https://github.com/mongoose-os-libs/bme280/blob/master/include/BME280.h)",
    "doc": "\n```c\ndouble readPressure() {\n    return mgos_bme280_read_pressure(_bme);\n  }\n```\n> \n> Reads the pressure.\n> Returns MGOS_BME280_ERROR if error.\n>    \n",
    "lang": "c"
  },
  {
    "name": "readHumidity",
    "file": "[BME280.h](https://github.com/mongoose-os-libs/bme280/blob/master/include/BME280.h)",
    "doc": "\n```c\ndouble readHumidity() {\n    return mgos_bme280_read_humidity(_bme);\n  }\n```\n> \n> Reads the humidity.\n> If the device is BMP280, the humidity will be 0.\n> Returns MGOS_BME280_ERROR if error.\n>    \n",
    "lang": "c"
  },
  {
    "name": "isBME280",
    "file": "[BME280.h](https://github.com/mongoose-os-libs/bme280/blob/master/include/BME280.h)",
    "doc": "\n```c\nbool isBME280() {\n    return mgos_bme280_is_bme280(_bme);\n  }\n```\n> \n> Returns true if a BME280 device is connected\n>    \n",
    "lang": "c"
  },
  {
    "name": "BME280Data.create()",
    "file": "[api_bme280.js](https://github.com/mongoose-os-libs/bme280/blob/master/mjs_fs/api_bme280.js)",
    "doc": "\n```javascript\nBME280Data.create()\n```\nCreates a BME280Data instance to be used for reading data from BME280.\nReturn value: an object with the methods described below.\n",
    "lang": "js"
  },
  {
    "name": "bmeData.free()",
    "file": "[api_bme280.js](https://github.com/mongoose-os-libs/bme280/blob/master/mjs_fs/api_bme280.js)",
    "doc": "\n```javascript\nbmeData.free()\n```\nFrees a BME280Data instance.\nNo methods can be called on this instance after that.\nReturn value: none.\n",
    "lang": "js"
  },
  {
    "name": "bmeData.temp()",
    "file": "[api_bme280.js](https://github.com/mongoose-os-libs/bme280/blob/master/mjs_fs/api_bme280.js)",
    "doc": "\n```javascript\nbmeData.temp()\n```\nGets the temperature component of the BME280Data structure.\n",
    "lang": "js"
  },
  {
    "name": "bmeData.press()",
    "file": "[api_bme280.js](https://github.com/mongoose-os-libs/bme280/blob/master/mjs_fs/api_bme280.js)",
    "doc": "\n```javascript\nbmeData.press()\n```\nGets the pressure component of the BME280Data structure.\n",
    "lang": "js"
  },
  {
    "name": "bmeData.humid()",
    "file": "[api_bme280.js](https://github.com/mongoose-os-libs/bme280/blob/master/mjs_fs/api_bme280.js)",
    "doc": "\n```javascript\nbmeData.humid()\n```\nGets the humidity component of the BME280Data structure.\n",
    "lang": "js"
  },
  {
    "name": "BME280.createI2C(address)",
    "file": "[api_bme280.js](https://github.com/mongoose-os-libs/bme280/blob/master/mjs_fs/api_bme280.js)",
    "doc": "\n```javascript\nBME280.createI2C(address)\n```\nCreates a BME280 instance on the I2C bus with the given address `address`.\nReturn value: an object with the methods described below.\n",
    "lang": "js"
  },
  {
    "name": "BME280.createSPI()",
    "file": "[api_bme280.js](https://github.com/mongoose-os-libs/bme280/blob/master/mjs_fs/api_bme280.js)",
    "doc": "\n```javascript\nBME280.createSPI()\n```\nCreates a BME280 instance on the SPI bus, using `spi.cs0_gpio`\nReturn value: an object with the methods described below.\n",
    "lang": "js"
  },
  {
    "name": "bme.free()",
    "file": "[api_bme280.js](https://github.com/mongoose-os-libs/bme280/blob/master/mjs_fs/api_bme280.js)",
    "doc": "\n```javascript\nbme.free()\n```\nFrees the  BME280 instance.\nNo methods can be called on this instance after that.\nReturn value: none.\n",
    "lang": "js"
  },
  {
    "name": "bme.readAll()",
    "file": "[api_bme280.js](https://github.com/mongoose-os-libs/bme280/blob/master/mjs_fs/api_bme280.js)",
    "doc": "\n```javascript\nbme.readAll()\n```\nReads all data into an instance of BME280Data\nReturns zero if success, otherwise a negative value.\n",
    "lang": "js"
  },
  {
    "name": "bme.readTemp()",
    "file": "[api_bme280.js](https://github.com/mongoose-os-libs/bme280/blob/master/mjs_fs/api_bme280.js)",
    "doc": "\n```javascript\nbme.readTemp()\n```\nReturn the temperature from the sensor in degrees C or\n`BME280.MGOS_BME280_ERROR` in case of a failure.\n",
    "lang": "js"
  },
  {
    "name": "bme.readPress()",
    "file": "[api_bme280.js](https://github.com/mongoose-os-libs/bme280/blob/master/mjs_fs/api_bme280.js)",
    "doc": "\n```javascript\nbme.readPress()\n```\nReturn the pressure from the sensor in Pa\n`BME280.MGOS_BME280_ERROR` in case of a failure.\n",
    "lang": "js"
  },
  {
    "name": "bme.readHumid()",
    "file": "[api_bme280.js](https://github.com/mongoose-os-libs/bme280/blob/master/mjs_fs/api_bme280.js)",
    "doc": "\n```javascript\nbme.readHumid()\n```\nReturn the humidity from the sensor in %RH\n`BME280.MGOS_BME280_ERROR` in case of a failure.\n",
    "lang": "js"
  },
  {
    "name": "bitmap.getPixel(x, y)",
    "file": "[api_bmp.js](https://github.com/mongoose-os-libs/bmp-loader/blob/master/mjs_fs/api_bmp.js)",
    "doc": "\n```javascript\nbitmap.getPixel(x, y)\n```\nReturns pixel's RGB value at pos x,y\n",
    "lang": "js"
  },
  {
    "name": "(sizeof",
    "file": "[mgos_bt.h](https://github.com/mongoose-os-libs/bt-common/blob/master/include/mgos_bt.h)",
    "doc": "\n```c\n#define MGOS_BT_ADDR_STR_LEN (sizeof(struct mgos_bt_addr) * 3 + 2 /* type */)\n#define MGOS_BT_UUID_STR_LEN (sizeof(struct mgos_bt_uuid) * 3)\n#define MGOS_BT_DEV_NAME_LEN 32\n```\n>  Each byte is transformed into 3 bytes: \"XX:\", and last byte into \"XX\\0\" \n",
    "lang": "c"
  },
  {
    "name": "GAP.parseName(advData)",
    "file": "[api_bt_gap.js](https://github.com/mongoose-os-libs/bt-common/blob/master/mjs_fs/api_bt_gap.js)",
    "doc": "\n```javascript\nGAP.parseName(advData)\n```\nParse name from adv data. Tries to get long, falls back to short.\n",
    "lang": "js"
  },
  {
    "name": "_read",
    "file": "[mgos_ccs811.h](https://github.com/mongoose-os-libs/ccs811-i2c/blob/master/include/mgos_ccs811.h)",
    "doc": "\n```c\nuint32_t read;                 // calls to _read()\n  uint32_t read_success;         // successful _read()\n  uint32_t read_success_cached;  // calls to _read() which were cached\n  // Note: read_errors := read - read_success - read_success_cached\n  double   read_success_usecs;   // time spent in successful uncached _read()\n};\n```\n> value of mg_time() upon last call to _read()\n",
    "lang": "c"
  },
  {
    "name": "mgos_ccs811_create",
    "file": "[mgos_ccs811.h](https://github.com/mongoose-os-libs/ccs811-i2c/blob/master/include/mgos_ccs811.h)",
    "doc": "\n```c\nstruct mgos_ccs811 *mgos_ccs811_create(struct mgos_i2c *i2c, uint8_t i2caddr);\n```\n> \n> Initialize a CCS811 on the I2C bus `i2c` at address specified in `i2caddr`\n> parameter (default CCS811 is on address 0x5A). The sensor will be polled for\n> validity, upon success a new `struct mgos_ccs811` is allocated and\n> returned. If the device could not be found, NULL is returned.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_ccs811_destroy",
    "file": "[mgos_ccs811.h](https://github.com/mongoose-os-libs/ccs811-i2c/blob/master/include/mgos_ccs811.h)",
    "doc": "\n```c\nvoid mgos_ccs811_destroy(struct mgos_ccs811 **sensor);\n```\n> \n> Destroy the data structure associated with a CCS811 device. The reference\n> to the pointer of the `struct mgos_ccs811` has to be provided, and upon\n> successful destruction, its associated memory will be freed and the pointer\n> set to NULL.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_ccs811_read",
    "file": "[mgos_ccs811.h](https://github.com/mongoose-os-libs/ccs811-i2c/blob/master/include/mgos_ccs811.h)",
    "doc": "\n```c\nbool mgos_ccs811_read(struct mgos_ccs811 *sensor);\n```\n> \n> The sensor will be polled for its temperature and humidity data. If the poll\n> has occured in the last `MGOS_CCS811_READ_DELAY` seconds, the cached data is\n> used (so as not to repeatedly poll the bus upon subsequent calls).\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_ccs811_setDriveMode",
    "file": "[mgos_ccs811.h](https://github.com/mongoose-os-libs/ccs811-i2c/blob/master/include/mgos_ccs811.h)",
    "doc": "\n```c\nbool mgos_ccs811_setDriveMode(struct mgos_ccs811 *sensor, enum mgos_ccs811_drive_mode_t mode);\n```\n> \n> Set the drive mode of the CCS811 sensor based on the `mode` argument\n> Returns true on success, false otherwise.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_ccs811_getDriveMode",
    "file": "[mgos_ccs811.h](https://github.com/mongoose-os-libs/ccs811-i2c/blob/master/include/mgos_ccs811.h)",
    "doc": "\n```c\nbool mgos_ccs811_getDriveMode(struct mgos_ccs811 *sensor, uint8_t *mode);\n```\n> \n> Retrieve the current drive mode (which will be one of `enum mgos_ccs811_drive_mode_t`\n> values into the byte pointed to by `mode`.\n> Returns true on success, false otherwise.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_ccs811_get_eco2",
    "file": "[mgos_ccs811.h](https://github.com/mongoose-os-libs/ccs811-i2c/blob/master/include/mgos_ccs811.h)",
    "doc": "\n```c\nfloat mgos_ccs811_get_eco2(struct mgos_ccs811 *sensor);\n```\n> \n> The sensor will be polled for its effective CO2 data. If the poll\n> has occured in the last `MGOS_CCS811_READ_DELAY` seconds, the cached data is\n> used (so as not to repeatedly poll the bus upon subsequent calls).\n> \n> Returns a value in eCO2 parts per million on success, NAN otherwise.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_ccs811_get_tvoc",
    "file": "[mgos_ccs811.h](https://github.com/mongoose-os-libs/ccs811-i2c/blob/master/include/mgos_ccs811.h)",
    "doc": "\n```c\nfloat mgos_ccs811_get_tvoc(struct mgos_ccs811 *sensor);\n```\n> \n> The sensor will be polled for its Volatile Organic Compounds (TVOC) data.\n> If the poll has occured in the last `MGOS_CCS811_READ_DELAY` seconds, the\n> cached data is used (so as not to repeatedly poll the bus upon subsequent\n> calls).\n> \n> Returns a value in TVOC parts per billion on success, NAN otherwise.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_ccs811_getStats",
    "file": "[mgos_ccs811.h](https://github.com/mongoose-os-libs/ccs811-i2c/blob/master/include/mgos_ccs811.h)",
    "doc": "\n```c\nbool mgos_ccs811_getStats(struct mgos_ccs811 *sensor, struct mgos_ccs811_stats *stats);\n```\n> \n> Returns the running statistics on the sensor interaction, the user provides\n> a pointer to a `struct mgos_ccs811_stats` object, which is filled in by this\n> call.\n> \n> Upon success, true is returned. Otherwise, false is returned, in which case\n> the contents of `stats` is undetermined.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_ccs811_i2c_init",
    "file": "[mgos_ccs811.h](https://github.com/mongoose-os-libs/ccs811-i2c/blob/master/include/mgos_ccs811.h)",
    "doc": "\n```c\nbool mgos_ccs811_i2c_init(void);\n```\n> \n> Initialization function for MGOS -- currently a noop.\n>  \n",
    "lang": "c"
  },
  {
    "name": "(*mgos_cron_callback_t)",
    "file": "[mgos_cron.h](https://github.com/mongoose-os-libs/cron/blob/master/include/mgos_cron.h)",
    "doc": "\n```c\ntypedef void (*mgos_cron_callback_t)(void *user_data, mgos_cron_id_t id);\n```\n> \n> Cron callback signature; `user_data` is a pointer given to\n> `mgos_cron_add()`, and `id` is the id of the corresponding cron job.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_cron_add",
    "file": "[mgos_cron.h](https://github.com/mongoose-os-libs/cron/blob/master/include/mgos_cron.h)",
    "doc": "\n```c\nmgos_cron_id_t mgos_cron_add(const char *expr, mgos_cron_callback_t cb,\n                             void *user_data);\n```\n> \n> Adds cron entry with the expression `expr` (a null-terminated string, should\n> be no longer that 256 bytes) and `cb` as a callback.\n> `user_data` is an arbitrary pointer which will be passed to `cb`.\n> Returns cron ID.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_cron_get_next_invocation",
    "file": "[mgos_cron.h](https://github.com/mongoose-os-libs/cron/blob/master/include/mgos_cron.h)",
    "doc": "\n```c\ntime_t mgos_cron_get_next_invocation(mgos_cron_id_t id, time_t date);\n```\n> \n> Calculate the next fire date after the specified date.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_cron_is_expr_valid",
    "file": "[mgos_cron.h](https://github.com/mongoose-os-libs/cron/blob/master/include/mgos_cron.h)",
    "doc": "\n```c\nbool mgos_cron_is_expr_valid(const char *expr, const char **perr);\n```\n> \n> Returns whether the given string is a valid cron expression or not. In case\n> of an error, if `perr` is not NULL, `*perr` is set to an error message; it\n> should NOT be freed by the caller.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_cron_get_user_data",
    "file": "[mgos_cron.h](https://github.com/mongoose-os-libs/cron/blob/master/include/mgos_cron.h)",
    "doc": "\n```c\nvoid *mgos_cron_get_user_data(mgos_cron_id_t id);\n```\n> \n> Returns user data pointer associated with the given cron job id.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_cron_remove",
    "file": "[mgos_cron.h](https://github.com/mongoose-os-libs/cron/blob/master/include/mgos_cron.h)",
    "doc": "\n```c\nvoid mgos_cron_remove(mgos_cron_id_t id);\n```\n> \n> Removes cron entry with a given cron ID.\n>  \n",
    "lang": "c"
  },
  {
    "name": "(",
    "file": "[mgos_crontab.h](https://github.com/mongoose-os-libs/crontab/blob/master/include/mgos_crontab.h)",
    "doc": "\n```c\n#define MGOS_CRONTAB_INVALID_JOB_ID ((mgos_crontab_job_id_t) 0)\n```\n> \n> Invalid value for the crontab job id.\n>  \n",
    "lang": "c"
  },
  {
    "name": "(*mgos_crontab_iterate_cb)",
    "file": "[mgos_crontab.h](https://github.com/mongoose-os-libs/crontab/blob/master/include/mgos_crontab.h)",
    "doc": "\n```c\ntypedef void (*mgos_crontab_iterate_cb)(mgos_crontab_job_id_t id,\n                                        struct mg_str at, bool enable,\n                                        struct mg_str action,\n                                        struct mg_str payload, void *userdata);\n```\n> \n> Callback for `mgos_crontab_iterate()`; all string data is invalidated when\n> the callback returns.\n>  \n",
    "lang": "c"
  },
  {
    "name": "(*mgos_crontab_cb)",
    "file": "[mgos_crontab.h](https://github.com/mongoose-os-libs/crontab/blob/master/include/mgos_crontab.h)",
    "doc": "\n```c\ntypedef void (*mgos_crontab_cb)(struct mg_str action, struct mg_str payload,\n                                void *userdata);\n```\n> \n> Prototype for a job handler to be registered with\n> `mgos_crontab_register_handler()`.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_crontab_job_add",
    "file": "[mgos_crontab.h](https://github.com/mongoose-os-libs/crontab/blob/master/include/mgos_crontab.h)",
    "doc": "\n```c\nbool mgos_crontab_job_add(struct mg_str at, bool enable, struct mg_str action,\n                          struct mg_str payload, mgos_crontab_job_id_t *pid,\n                          char **perr);\n```\n> \n> Add a new job. Passed string data is not retained. If `pid` is not NULL,\n> resulting job id is written there.\n> \n> Returns true in case of success, false otherwise.\n> \n> If `perr` is not NULL, the error message will be written there (or NULL\n> in case of success). The caller should free the error message.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_crontab_job_edit",
    "file": "[mgos_crontab.h](https://github.com/mongoose-os-libs/crontab/blob/master/include/mgos_crontab.h)",
    "doc": "\n```c\nbool mgos_crontab_job_edit(mgos_crontab_job_id_t id, struct mg_str at,\n                           bool enable, struct mg_str action,\n                           struct mg_str payload, char **perr);\n```\n> \n> Edit a job by its id. Passed string data is not retained.\n> \n> Returns true in case of success, false otherwise.\n> \n> If `perr` is not NULL, the error message will be written there (or NULL\n> in case of success). The caller should free the error message.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_crontab_job_remove",
    "file": "[mgos_crontab.h](https://github.com/mongoose-os-libs/crontab/blob/master/include/mgos_crontab.h)",
    "doc": "\n```c\nbool mgos_crontab_job_remove(mgos_crontab_job_id_t id, char **perr);\n```\n> \n> Remove a job by its id.\n> \n> Returns true in case of success, false otherwise.\n> \n> If `perr` is not NULL, the error message will be written there (or NULL\n> in case of success). The caller should free the error message.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_crontab_job_get",
    "file": "[mgos_crontab.h](https://github.com/mongoose-os-libs/crontab/blob/master/include/mgos_crontab.h)",
    "doc": "\n```c\nbool mgos_crontab_job_get(mgos_crontab_job_id_t id, struct mg_str *at,\n                          bool *enable, struct mg_str *action,\n                          struct mg_str *payload, char **perr);\n```\n> \n> Get job details by the job id. All output pointers (`at`, `enable`, `action`,\n> `payload`) are optional (allowed to be NULL). For non-NULL string outputs\n> (`at`, `action` and `payload`), the memory is allocated separately and\n> the caller should free it.\n> \n> Returns true in case of success, false otherwise.\n> \n> If `perr` is not NULL, the error message will be written there (or NULL\n> in case of success). The caller should free the error message.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_crontab_iterate",
    "file": "[mgos_crontab.h](https://github.com/mongoose-os-libs/crontab/blob/master/include/mgos_crontab.h)",
    "doc": "\n```c\nbool mgos_crontab_iterate(mgos_crontab_iterate_cb cb, void *userdata,\n                          char **perr);\n```\n> \n> Iterate over all jobs in crontab, see `mgos_crontab_iterate_cb` for details.\n> \n> Returns true in case of success, false otherwise.\n> \n> If `perr` is not NULL, the error message will be written there (or NULL\n> in case of success). The caller should free the error message.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_crontab_register_handler",
    "file": "[mgos_crontab.h](https://github.com/mongoose-os-libs/crontab/blob/master/include/mgos_crontab.h)",
    "doc": "\n```c\nvoid mgos_crontab_register_handler(struct mg_str action, mgos_crontab_cb cb,\n                                   void *userdata);\n```\n> \n> Add a handler for the given string action\n> \n> Example:\n> \n> ```c\n> static void my_foo_cb(struct mg_str action,\n>                       struct mg_str payload, void *userdata) {\n>   LOG(LL_INFO, (\"Crontab foo job fired! Payload: %.*s\", payload.len,\n> payload.p));\n>   (void) action;\n>   (void) userdata;\n> }\n> \n> // Somewhere else:\n> mgos_crontab_register_handler(\"foo\", my_foo_cb, NULL);\n> ```\n> \n> The code above maps action `foo` in the JSON to the callback `my_foo_cb`.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_crontab_get_next_invocation",
    "file": "[mgos_crontab.h](https://github.com/mongoose-os-libs/crontab/blob/master/include/mgos_crontab.h)",
    "doc": "\n```c\ntime_t mgos_crontab_get_next_invocation(mgos_crontab_job_id_t id, time_t date);\n```\n> \n> Calculate the next fire date after the specified date, using crontab ID\n> (returned by all cron RPC methods)\n>  \n",
    "lang": "c"
  },
  {
    "name": "begin",
    "file": "[DallasRmt.h](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/include/DallasRmt.h)",
    "doc": "\n```c\nvoid begin(void);\n```\n> \n> Initialises the bus\n>    \n",
    "lang": "c"
  },
  {
    "name": "getDeviceCount",
    "file": "[DallasRmt.h](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/include/DallasRmt.h)",
    "doc": "\n```c\nuint8_t getDeviceCount(void) {\n    return _devices;\n  }\n```\n> \n>  Returns the number of devices found on the bus\n>    \n",
    "lang": "c"
  },
  {
    "name": "validAddress",
    "file": "[DallasRmt.h](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/include/DallasRmt.h)",
    "doc": "\n```c\nbool validAddress(const uint8_t *);\n```\n> \n>  Returns true if address is valid\n>    \n",
    "lang": "c"
  },
  {
    "name": "validFamily",
    "file": "[DallasRmt.h](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/include/DallasRmt.h)",
    "doc": "\n```c\nbool validFamily(const uint8_t *deviceAddress);\n```\n> \n> Returns true if address is of the family of sensors the lib supports.\n>    \n",
    "lang": "c"
  },
  {
    "name": "getAddress",
    "file": "[DallasRmt.h](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/include/DallasRmt.h)",
    "doc": "\n```c\nbool getAddress(uint8_t *deviceAddress, uint8_t index);\n```\n> \n> Finds an address at a given index on the bus\n>    \n",
    "lang": "c"
  },
  {
    "name": "isConnected",
    "file": "[DallasRmt.h](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/include/DallasRmt.h)",
    "doc": "\n```c\nbool isConnected(const uint8_t *);\n```\n> \n> Attempts to determine if the device at the given address is connected to\n> the bus\n>    \n",
    "lang": "c"
  },
  {
    "name": "isConnected",
    "file": "[DallasRmt.h](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/include/DallasRmt.h)",
    "doc": "\n```c\nbool isConnected(const uint8_t *, uint8_t *);\n```\n> \n> Attempts to determine if the device at the given address is connected to\n> the bus.\n> Also allows for updating the read scratchpad\n>    \n",
    "lang": "c"
  },
  {
    "name": "readScratchPad",
    "file": "[DallasRmt.h](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/include/DallasRmt.h)",
    "doc": "\n```c\nbool readScratchPad(const uint8_t *, uint8_t *);\n```\n> \n> Reads device's scratchpad\n>    \n",
    "lang": "c"
  },
  {
    "name": "writeScratchPad",
    "file": "[DallasRmt.h](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/include/DallasRmt.h)",
    "doc": "\n```c\nvoid writeScratchPad(const uint8_t *, const uint8_t *);\n```\n> \n> Writes device's scratchpad\n>    \n",
    "lang": "c"
  },
  {
    "name": "readPowerSupply",
    "file": "[DallasRmt.h](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/include/DallasRmt.h)",
    "doc": "\n```c\nbool readPowerSupply(const uint8_t *deviceAddress);\n```\n> \n> Reads device's power requirements\n>    \n",
    "lang": "c"
  },
  {
    "name": "getResolution",
    "file": "[DallasRmt.h](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/include/DallasRmt.h)",
    "doc": "\n```c\nuint8_t getResolution() {\n    return _bitResolution;\n  }\n  /*\n   * Returns the device's resolution: 9, 10, 11, or 12 bits\n   */\n  uint8_t getResolution(const uint8_t *deviceAddress);\n```\n> \n> Gets the global resolution\n>    \n",
    "lang": "c"
  },
  {
    "name": "setResolution",
    "file": "[DallasRmt.h](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/include/DallasRmt.h)",
    "doc": "\n```c\nvoid setResolution(uint8_t);\n```\n> \n> Sets the global resolution to 9, 10, 11, or 12 bits\n>    \n",
    "lang": "c"
  },
  {
    "name": "setResolution",
    "file": "[DallasRmt.h](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/include/DallasRmt.h)",
    "doc": "\n```c\nbool setResolution(const uint8_t *, uint8_t,\n                     bool skipGlobalBitResolutionCalculation = false);\n```\n> \n> Sets the resolution of a device to 9, 10, 11, or 12 bits\n>    \n",
    "lang": "c"
  },
  {
    "name": "setWaitForConversion",
    "file": "[DallasRmt.h](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/include/DallasRmt.h)",
    "doc": "\n```c\nvoid setWaitForConversion(bool value) {\n    _waitForConversion = value;\n  }\n```\n> \n> Sets/gets the value of the waitForConversion flag\n> true : function requestTemperature() etc returns when conversion is ready\n> false: function requestTemperature() etc returns immediately (USE WITH\n> CARE!!)\n>        (1) programmer has to check if the needed delay has passed\n>        (2) but the application can do meaningful things in that time\n>    \n",
    "lang": "c"
  },
  {
    "name": "setCheckForConversion",
    "file": "[DallasRmt.h](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/include/DallasRmt.h)",
    "doc": "\n```c\nvoid setCheckForConversion(bool value) {\n    _checkForConversion = value;\n  }\n```\n> \n> Sets/gets the checkForConversion flag\n> sets the value of the checkForConversion flag\n> true : function requestTemperature() etc will 'listen' to an IC to\n> determine whether a conversion is complete\n> false: function requestTemperature() etc will wait a set time (worst case\n> scenario) for a conversion to complete\n>    \n",
    "lang": "c"
  },
  {
    "name": "requestTemperatures",
    "file": "[DallasRmt.h](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/include/DallasRmt.h)",
    "doc": "\n```c\nvoid requestTemperatures(void);\n  // sends command for one device to perform a temperature conversion by address\n  bool requestTemperaturesByAddress(const uint8_t *);\n```\n> \n> Sends command for all devices on the bus to perform a temperature\n> conversion\n>    \n",
    "lang": "c"
  },
  {
    "name": "requestTemperaturesByIndex",
    "file": "[DallasRmt.h](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/include/DallasRmt.h)",
    "doc": "\n```c\nbool requestTemperaturesByIndex(uint8_t);\n```\n> \n> Sends command for one device to perform a temperature conversion by index\n>    \n",
    "lang": "c"
  },
  {
    "name": "getTemp",
    "file": "[DallasRmt.h](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/include/DallasRmt.h)",
    "doc": "\n```c\nint16_t getTemp(const uint8_t *);\n```\n> \n> Returns temperature raw value (12 bit integer of 1/128 degrees C)\n>    \n",
    "lang": "c"
  },
  {
    "name": "getTempC",
    "file": "[DallasRmt.h](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/include/DallasRmt.h)",
    "doc": "\n```c\nfloat getTempC(const uint8_t *);\n```\n> \n> Returns temperature in degrees C\n>    \n",
    "lang": "c"
  },
  {
    "name": "getTempF",
    "file": "[DallasRmt.h](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/include/DallasRmt.h)",
    "doc": "\n```c\nfloat getTempF(const uint8_t *);\n```\n> \n> Returns temperature in degrees F\n>    \n",
    "lang": "c"
  },
  {
    "name": "getTempCByIndex",
    "file": "[DallasRmt.h](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/include/DallasRmt.h)",
    "doc": "\n```c\nfloat getTempCByIndex(uint8_t);\n```\n> \n> Get temperature for device index (slow)\n>    \n",
    "lang": "c"
  },
  {
    "name": "getTempFByIndex",
    "file": "[DallasRmt.h](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/include/DallasRmt.h)",
    "doc": "\n```c\nfloat getTempFByIndex(uint8_t);\n```\n> \n> Get temperature for device index (slow)\n>    \n",
    "lang": "c"
  },
  {
    "name": "isParasitePowerMode",
    "file": "[DallasRmt.h](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/include/DallasRmt.h)",
    "doc": "\n```c\nbool isParasitePowerMode(void) {\n    return _parasite;\n  }\n```\n> \n> Returns true if the bus requires parasite power\n>    \n",
    "lang": "c"
  },
  {
    "name": "isConversionComplete",
    "file": "[DallasRmt.h](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/include/DallasRmt.h)",
    "doc": "\n```c\nbool isConversionComplete(void);\n```\n> \n> Is a conversion complete on the wire?\n>    \n",
    "lang": "c"
  },
  {
    "name": "toFahrenheit",
    "file": "[DallasRmt.h](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/include/DallasRmt.h)",
    "doc": "\n```c\nstatic float toFahrenheit(float);\n```\n> \n> Convert from Celsius to Fahrenheit\n>    \n",
    "lang": "c"
  },
  {
    "name": "toCelsius",
    "file": "[DallasRmt.h](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/include/DallasRmt.h)",
    "doc": "\n```c\nstatic float toCelsius(float);\n```\n> \n> Convert from Fahrenheit to Celsius\n>    \n",
    "lang": "c"
  },
  {
    "name": "rawToCelsius",
    "file": "[DallasRmt.h](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/include/DallasRmt.h)",
    "doc": "\n```c\nstatic float rawToCelsius(int16_t);\n```\n> \n> Convert from raw to Celsius\n>    \n",
    "lang": "c"
  },
  {
    "name": "rawToFahrenheit",
    "file": "[DallasRmt.h](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/include/DallasRmt.h)",
    "doc": "\n```c\nstatic float rawToFahrenheit(int16_t);\n```\n> \n> Convert from raw to Fahrenheit\n>    \n",
    "lang": "c"
  },
  {
    "name": "calculateTemperature",
    "file": "[DallasRmt.h](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/include/DallasRmt.h)",
    "doc": "\n```c\nint16_t calculateTemperature(const uint8_t *, uint8_t *);\n```\n> \n> Reads scratchpad and returns the raw temperature\n>    \n",
    "lang": "c"
  },
  {
    "name": "DallasRmt.create(pin, rmt_rx, rmt_tx)",
    "file": "[api_dallas_rmt.js](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/mjs_fs/api_dallas_rmt.js)",
    "doc": "\n```javascript\nDallasRmt.create(pin, rmt_rx, rmt_tx)\n```\nCreate and return an instance of the dallas temperature: an object with\nmethods described below.\n`pin` - onewire pin number\n`rmt_rx` - rx RMT channel\n`rmt_tx` - tx RMT channel\n\nExample:\n```javascript\nlet myDT = DallasRmt.create(12 /* onewire pin number */, 0 /*RMT rx channel*/, 1 /*RMT tx channel*/);\n```\n",
    "lang": "js"
  },
  {
    "name": "myDT.close()",
    "file": "[api_dallas_rmt.js](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/mjs_fs/api_dallas_rmt.js)",
    "doc": "\n```javascript\nmyDT.close()\n```\nClose DallasRmt handle. Return value: none.\n",
    "lang": "js"
  },
  {
    "name": "myDT.begin()",
    "file": "[api_dallas_rmt.js](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/mjs_fs/api_dallas_rmt.js)",
    "doc": "\n```javascript\nmyDT.begin()\n```\nInitialise the sensor. Return value: none.\nbegin: function () {\n   return DallasRmt._begin(this.dt);\n},\n## **`myDT.getDeviceCount()`**\nReturn the number of devices found on the bus.\nIf an operaiton is failed, 0 is returned.\n",
    "lang": "js"
  },
  {
    "name": "myDT.validAddress(addr)",
    "file": "[api_dallas_rmt.js](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/mjs_fs/api_dallas_rmt.js)",
    "doc": "\n```javascript\nmyDT.validAddress(addr)\n```\nCheck if given onewire `addr` (8-byte string) is valid; returns 1 if it\nis, or 0 otherwise.\n",
    "lang": "js"
  },
  {
    "name": "myDT.validFamily(addr)",
    "file": "[api_dallas_rmt.js](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/mjs_fs/api_dallas_rmt.js)",
    "doc": "\n```javascript\nmyDT.validFamily(addr)\n```\nReturn 1 if onewire address `addr` (8-byte string) is of the family of\nsensors the lib supports.  Return always 0 if an operaiton failed.\n",
    "lang": "js"
  },
  {
    "name": "myDT.getAddress(addr, idx)",
    "file": "[api_dallas_rmt.js](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/mjs_fs/api_dallas_rmt.js)",
    "doc": "\n```javascript\nmyDT.getAddress(addr, idx)\n```\nFind an onewire address at a given index `idx` on the bus. Resulting\naddress is written into the provided string buffer `addr`, which should\nbe 8 bytes lont.\nReturn value: 1 in case of success, 0 otherwise.\nExample:\n```javascript\nload(\"api_sys.js\");\nload(\"api_dallas_rmt.js\");\n\nlet addr = myDT.createAddress;\nlet res = myDT.getAddress(addr, 0);\nif (res === 1) {\n  print(\"found:\", addr);\n} else {\n  print(\"not found\");\n}\n```\n",
    "lang": "js"
  },
  {
    "name": "myDT.isConnected(addr)",
    "file": "[api_dallas_rmt.js](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/mjs_fs/api_dallas_rmt.js)",
    "doc": "\n```javascript\nmyDT.isConnected(addr)\n```\nDetermine if the device at the given onewire address (8-byte string) is\nconnected to the bus.\nReturn value: 1 if device is connected, 0 otherwise.\n",
    "lang": "js"
  },
  {
    "name": "myDT.isConnectedWithScratchPad(addr, sp)",
    "file": "[api_dallas_rmt.js](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/mjs_fs/api_dallas_rmt.js)",
    "doc": "\n```javascript\nmyDT.isConnectedWithScratchPad(addr, sp)\n```\nDetermine if the device at the given onewire address (8-byte string) is\nconnected to the bus, and if so, read the scratch pad to the provided\nbuffer (9-byte string).\nReturn value: 1 if device is connected (and a scratchpad is read), 0\notherwise.\nExample:\n```javascript\nload(\"api_sys.js\");\nload(\"api_dallas_rmt.js\");\n\nlet sp = myDT.createScratchPad();\nlet res = myDT.isConnectedWithScratchPad(\"\\x28\\xff\\x2b\\x45\\x4c\\x04\\x00\\x10\", sp);\nif (res === 1) {\n  print(\"connected, scratchpad:\", sp);\n} else {\n  print(\"not connected\");\n}\n```\n",
    "lang": "js"
  },
  {
    "name": "myDT.readScratchPad(addr, sp)",
    "file": "[api_dallas_rmt.js](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/mjs_fs/api_dallas_rmt.js)",
    "doc": "\n```javascript\nmyDT.readScratchPad(addr, sp)\n```\nRead device's scratchpad.\n`sp` is a string buffer (minimum 9 bytes length) to read scratchpad\ninto.\nReturn 1 in case of success, 0 otherwise.\nExample:\n```javascript\nload(\"api_sys.js\");\nload(\"api_dallas_rmt.js\");\n\nlet sp = createScratchPad();\nlet res = myDT.readScratchPad(\"\\x28\\xff\\x2b\\x45\\x4c\\x04\\x00\\x10\", sp);\nif (res === 1) {\n  print(\"scratchpad:\", sp);\n} else {\n  print(\"failed to read scratchpad\");\n}\n```\n",
    "lang": "js"
  },
  {
    "name": "myDT.writeScratchPad(addr, sp)",
    "file": "[api_dallas_rmt.js](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/mjs_fs/api_dallas_rmt.js)",
    "doc": "\n```javascript\nmyDT.writeScratchPad(addr, sp)\n```\nWrite device's scratchpad `sp` (which should be a 9-byte string) by\nthe provided onewire address `addr` (a 8-byte string).\nReturn value: none.\n",
    "lang": "js"
  },
  {
    "name": "myDT.readPowerSupply()",
    "file": "[api_dallas_rmt.js](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/mjs_fs/api_dallas_rmt.js)",
    "doc": "\n```javascript\nmyDT.readPowerSupply()\n```\nRead device's power requirements.\nReturn 1 if device needs parasite power.\nReturn always 0 if an operaiton failed.\n",
    "lang": "js"
  },
  {
    "name": "myDT.getGlobalResolution()",
    "file": "[api_dallas_rmt.js](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/mjs_fs/api_dallas_rmt.js)",
    "doc": "\n```javascript\nmyDT.getGlobalResolution()\n```\nGet global resolution in bits. Return value: 9, 10, 11 or 12.\nIn case of a failure, returns 0.\n",
    "lang": "js"
  },
  {
    "name": "myDT.setGlobalResolution(res)",
    "file": "[api_dallas_rmt.js](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/mjs_fs/api_dallas_rmt.js)",
    "doc": "\n```javascript\nmyDT.setGlobalResolution(res)\n```\nSet global resolution `res` in bits, which can be either 9, 10, 11, or\n12. If given resolution is out of range, 9 bits is used.\nReturn value: none.\n",
    "lang": "js"
  },
  {
    "name": "myDT.getResolution(addr)",
    "file": "[api_dallas_rmt.js](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/mjs_fs/api_dallas_rmt.js)",
    "doc": "\n```javascript\nmyDT.getResolution(addr)\n```\nGet device's resolution in bits. Return value: 9, 10, 11 or 12.\nIn case of a failure, returns 0.\n",
    "lang": "js"
  },
  {
    "name": "myDT.setResolution(addr, res, skip)",
    "file": "[api_dallas_rmt.js](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/mjs_fs/api_dallas_rmt.js)",
    "doc": "\n```javascript\nmyDT.setResolution(addr, res, skip)\n```\nSet resolution of a device with onewire address `addr` to 9, 10, 11, or\n12 bits.  If given resolution is out of range, 9 bits is used.\nReturn 1 in case of success, 0 otherwise.\n",
    "lang": "js"
  },
  {
    "name": "myDT.setWaitForConversion(waitForConversion)",
    "file": "[api_dallas_rmt.js](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/mjs_fs/api_dallas_rmt.js)",
    "doc": "\n```javascript\nmyDT.setWaitForConversion(waitForConversion)\n```\nSet/clear the waitForConversion flag.\nReturn value: none.\n",
    "lang": "js"
  },
  {
    "name": "myDT.getWaitForConversion()",
    "file": "[api_dallas_rmt.js](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/mjs_fs/api_dallas_rmt.js)",
    "doc": "\n```javascript\nmyDT.getWaitForConversion()\n```\nGet the value of the waitForConversion flag: either 1 or 0. In case\nof a failure, return 0.\n",
    "lang": "js"
  },
  {
    "name": "myDT.setCheckForConversion(checkForConversion)",
    "file": "[api_dallas_rmt.js](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/mjs_fs/api_dallas_rmt.js)",
    "doc": "\n```javascript\nmyDT.setCheckForConversion(checkForConversion)\n```\nSet/clear the `checkForConversion` flag.\n",
    "lang": "js"
  },
  {
    "name": "myDT.getCheckForConversion()",
    "file": "[api_dallas_rmt.js](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/mjs_fs/api_dallas_rmt.js)",
    "doc": "\n```javascript\nmyDT.getCheckForConversion()\n```\nGet the value of the `checkForConversion` flag: either 1 or 0. In case\nof a failure, return 0.\n",
    "lang": "js"
  },
  {
    "name": "myDT.requestTemperatures()",
    "file": "[api_dallas_rmt.js](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/mjs_fs/api_dallas_rmt.js)",
    "doc": "\n```javascript\nmyDT.requestTemperatures()\n```\nSend command for all devices on the bus to perform a temperature\nconversion.\n\nReturn value: 1 in case of success, 0 otherwise.\n",
    "lang": "js"
  },
  {
    "name": "myDT.requestTemperaturesByAddress(addr)",
    "file": "[api_dallas_rmt.js](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/mjs_fs/api_dallas_rmt.js)",
    "doc": "\n```javascript\nmyDT.requestTemperaturesByAddress(addr)\n```\nSend command to a device with the given onewire address `addr` to\nperform a temperature conversion.\n\nReturn value: 1 in case of success, 0 otherwise.\n",
    "lang": "js"
  },
  {
    "name": "myDT.requestTemperaturesByIndex(idx)",
    "file": "[api_dallas_rmt.js](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/mjs_fs/api_dallas_rmt.js)",
    "doc": "\n```javascript\nmyDT.requestTemperaturesByIndex(idx)\n```\nSend command to a device with the given index `idx` to perform a\ntemperature conversion.\n\nReturn value: 1 in case of success, 0 otherwise.\n",
    "lang": "js"
  },
  {
    "name": "myDT.getTemp(addr)",
    "file": "[api_dallas_rmt.js](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/mjs_fs/api_dallas_rmt.js)",
    "doc": "\n```javascript\nmyDT.getTemp(addr)\n```\nReturn raw temperature value (12 bit integer of 1/128 degrees C)\nor `DallasRmt.DEVICE_DISCONNECTED_RAW` in case of a failure.\n",
    "lang": "js"
  },
  {
    "name": "myDT.getTempC(addr)",
    "file": "[api_dallas_rmt.js](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/mjs_fs/api_dallas_rmt.js)",
    "doc": "\n```javascript\nmyDT.getTempC(addr)\n```\nReturns temperature in degrees C or\n`DallasRmt.DEVICE_DISCONNECTED_C` in case of a failure.\n",
    "lang": "js"
  },
  {
    "name": "myDT.getTempF(addr)",
    "file": "[api_dallas_rmt.js](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/mjs_fs/api_dallas_rmt.js)",
    "doc": "\n```javascript\nmyDT.getTempF(addr)\n```\nReturns temperature in degrees F or\n`DallasRmt.DEVICE_DISCONNECTED_F` in case of a failure.\n",
    "lang": "js"
  },
  {
    "name": "myDT.getTempCByIndex(idx)",
    "file": "[api_dallas_rmt.js](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/mjs_fs/api_dallas_rmt.js)",
    "doc": "\n```javascript\nmyDT.getTempCByIndex(idx)\n```\nGet temperature from the device with the given index `idx` in degrees C,\nor `DallasRmt.DEVICE_DISCONNECTED_C` in case of a failure.\n",
    "lang": "js"
  },
  {
    "name": "myDT.getTempFByIndex(idx)",
    "file": "[api_dallas_rmt.js](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/mjs_fs/api_dallas_rmt.js)",
    "doc": "\n```javascript\nmyDT.getTempFByIndex(idx)\n```\nGet temperature from the device with the given index `idx` in degrees F,\nor `DallasRmt.DEVICE_DISCONNECTED_F` in case of a failure.\n",
    "lang": "js"
  },
  {
    "name": "myDT.isParasitePowerMode()",
    "file": "[api_dallas_rmt.js](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/mjs_fs/api_dallas_rmt.js)",
    "doc": "\n```javascript\nmyDT.isParasitePowerMode()\n```\nReturn 1 if the bus requires parasite power, 0 otherwise. In case of a\nfailure return 0.\n",
    "lang": "js"
  },
  {
    "name": "myDT.isConversionComplete()",
    "file": "[api_dallas_rmt.js](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/mjs_fs/api_dallas_rmt.js)",
    "doc": "\n```javascript\nmyDT.isConversionComplete()\n```\nReturn whether a conversion is completed.\n",
    "lang": "js"
  },
  {
    "name": "myDT.millisToWaitForConversion(res)",
    "file": "[api_dallas_rmt.js](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/mjs_fs/api_dallas_rmt.js)",
    "doc": "\n```javascript\nmyDT.millisToWaitForConversion(res)\n```\nReturn number of milliseconds to wait until the conversion is completed\nfor the given resolution `res` in bits (9, 10, 11 or 12).\nIn case of a failure, return 0.\n",
    "lang": "js"
  },
  {
    "name": "myDT.toHexStr(addr)",
    "file": "[api_dallas_rmt.js](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/mjs_fs/api_dallas_rmt.js)",
    "doc": "\n```javascript\nmyDT.toHexStr(addr)\n```\nReturn device address `addr` in the hex format.\n",
    "lang": "js"
  },
  {
    "name": "myDT.createAddress()",
    "file": "[api_dallas_rmt.js](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/mjs_fs/api_dallas_rmt.js)",
    "doc": "\n```javascript\nmyDT.createAddress()\n```\nReturn an 8 bytes empty string to be used with `*Address` function\n",
    "lang": "js"
  },
  {
    "name": "myDT.createScratchPad()",
    "file": "[api_dallas_rmt.js](https://github.com/mongoose-os-libs/dallas-rmt/blob/master/mjs_fs/api_dallas_rmt.js)",
    "doc": "\n```javascript\nmyDT.createScratchPad()\n```\nReturn an 9 bytes empty string to be used with `...ScratchPad` function\n",
    "lang": "js"
  },
  {
    "name": "mgos_dash_is_connected",
    "file": "[mgos_dash.h](https://github.com/mongoose-os-libs/dash/blob/master/include/mgos_dash.h)",
    "doc": "\n```c\nbool mgos_dash_is_connected(void);\n```\n>  Returns true if mDash connection is up, false otherwise. \n",
    "lang": "c"
  },
  {
    "name": "mgos_dash_notifyf",
    "file": "[mgos_dash.h](https://github.com/mongoose-os-libs/dash/blob/master/include/mgos_dash.h)",
    "doc": "\n```c\nvoid mgos_dash_notifyf(const char *method, const char *json_fmt, ...);\n```\n> \n> Send an notification RPC to the dashboard that does not require an answer.\n> Example - report statistical data:\n> ```c\n>    mgos_dash_notifyf(\"Data\", \"[%d, %d]\", value1, value2);\n> ```\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_dash_notify",
    "file": "[mgos_dash.h](https://github.com/mongoose-os-libs/dash/blob/master/include/mgos_dash.h)",
    "doc": "\n```c\nvoid mgos_dash_notify(const char *method, const char *data);\n```\n> \n> Same as `mgos_dash_notifyf()` but accepts stringified data.\n>  \n",
    "lang": "c"
  },
  {
    "name": "Dash.isConnected()",
    "file": "[api_dash.js](https://github.com/mongoose-os-libs/dash/blob/master/mjs_fs/api_dash.js)",
    "doc": "\n```javascript\nDash.isConnected()\n```\nReturn value: true if mDash connection is up, false otherwise.\n",
    "lang": "js"
  },
  {
    "name": "Dash.notify(name, data)",
    "file": "[api_dash.js](https://github.com/mongoose-os-libs/dash/blob/master/mjs_fs/api_dash.js)",
    "doc": "\n```javascript\nDash.notify(name, data)\n```\nSend notification event to mDash. `name` is an event name,\n`data` is either a string or an object. A string is sent as-is,\nand object gets `JSON.stringify()`-ed then sent.\n\nReturn value: none.\n\nExample:\n```javascript\nDash.notify('Data', {temperature: 12.34});\n```\n",
    "lang": "js"
  },
  {
    "name": "_read",
    "file": "[mgos_dht.h](https://github.com/mongoose-os-libs/dht/blob/master/include/mgos_dht.h)",
    "doc": "\n```c\nuint32_t read;                 // calls to _read()\n  uint32_t read_success;         // successful _read()\n  uint32_t read_success_cached;  // calls to _read() which were cached\n  // Note: read_errors := read - read_success - read_success_cached\n  double read_success_usecs;     // time spent in successful uncached _read()\n};\n```\n> value of mg_time() upon last call to _read()\n",
    "lang": "c"
  },
  {
    "name": "mgos_dht_create",
    "file": "[mgos_dht.h](https://github.com/mongoose-os-libs/dht/blob/master/include/mgos_dht.h)",
    "doc": "\n```c\nstruct mgos_dht *mgos_dht_create(int pin, enum dht_type type);\n```\n>  Initialise DHT sensor. Return an opaque DHT handle, or `NULL` on error. \n",
    "lang": "c"
  },
  {
    "name": "mgos_dht_close",
    "file": "[mgos_dht.h](https://github.com/mongoose-os-libs/dht/blob/master/include/mgos_dht.h)",
    "doc": "\n```c\nvoid mgos_dht_close(struct mgos_dht *dht);\n```\n>  Close DHT handle. \n",
    "lang": "c"
  },
  {
    "name": "mgos_dht_get_temp",
    "file": "[mgos_dht.h](https://github.com/mongoose-os-libs/dht/blob/master/include/mgos_dht.h)",
    "doc": "\n```c\nfloat mgos_dht_get_temp(struct mgos_dht *dht);\n```\n>  Return temperature in DegC or 'NAN' on failure. \n",
    "lang": "c"
  },
  {
    "name": "mgos_dht_get_humidity",
    "file": "[mgos_dht.h](https://github.com/mongoose-os-libs/dht/blob/master/include/mgos_dht.h)",
    "doc": "\n```c\nfloat mgos_dht_get_humidity(struct mgos_dht *dht);\n```\n>  Return humidity in % or 'NAN' on failure. \n",
    "lang": "c"
  },
  {
    "name": "mgos_dht_getStats",
    "file": "[mgos_dht.h](https://github.com/mongoose-os-libs/dht/blob/master/include/mgos_dht.h)",
    "doc": "\n```c\nbool mgos_dht_getStats(struct mgos_dht *dht, struct mgos_dht_stats *stats);\n```\n> \n> Returns the running statistics on the sensor interaction, the user provides\n> a pointer to a `struct mgos_dht_stats` object, which is filled in by this\n> call.\n> \n> Upon success, true is returned. Otherwise, false is returned, in which case\n> the contents of `stats` is undetermined.\n>  \n",
    "lang": "c"
  },
  {
    "name": "DHT.create(pin, type)",
    "file": "[api_dht.js](https://github.com/mongoose-os-libs/dht/blob/master/mjs_fs/api_dht.js)",
    "doc": "\n```javascript\nDHT.create(pin, type)\n```\nCreate a DHT object. `type` could be `DHT.DHT11`, `DHT.DHT21`,\n`DHT.DHT22`. Return value: an object with the methods described below, or\n'null' in case of a failure.\nExample:\n```javascript\nlet mydht = DHT.create(5, DHT.DHT11);\nprint('Temperature:', mydht.getTemp());\n```\n",
    "lang": "js"
  },
  {
    "name": "mydht.close()",
    "file": "[api_dht.js](https://github.com/mongoose-os-libs/dht/blob/master/mjs_fs/api_dht.js)",
    "doc": "\n```javascript\nmydht.close()\n```\nClose DHT handle. Return value: none.\n",
    "lang": "js"
  },
  {
    "name": "mydht.getTemp()",
    "file": "[api_dht.js](https://github.com/mongoose-os-libs/dht/blob/master/mjs_fs/api_dht.js)",
    "doc": "\n```javascript\nmydht.getTemp()\n```\nReturn temperature in degrees C or 'NaN' in case of a failure.\n",
    "lang": "js"
  },
  {
    "name": "mydht.getHumidity()",
    "file": "[api_dht.js](https://github.com/mongoose-os-libs/dht/blob/master/mjs_fs/api_dht.js)",
    "doc": "\n```javascript\nmydht.getHumidity()\n```\nReturn humidity in RH% or 'NaN' in case of a failure.\n",
    "lang": "js"
  },
  {
    "name": "mgos_dns_sd_get_host_name",
    "file": "[mgos_dns_sd.h](https://github.com/mongoose-os-libs/dns-sd/blob/master/include/mgos_dns_sd.h)",
    "doc": "\n```c\nconst char *mgos_dns_sd_get_host_name(void);\n```\n> \n> Return currently configure DNS-SD hostname.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_dns_sd_add_service_instance",
    "file": "[mgos_dns_sd.h](https://github.com/mongoose-os-libs/dns-sd/blob/master/include/mgos_dns_sd.h)",
    "doc": "\n```c\nbool mgos_dns_sd_add_service_instance(\n    const char *instance, const char *proto, int port,\n    const struct mgos_dns_sd_txt_entry *txt_entries);\n```\n> \n> Add a service instance.\n> If service instance already exists, its definition will be replaced.\n> A record will be added automatically to point to the device.\n> If txt_entries is not NULL, it must end with an entry with key=NULL.\n> \n> Example (for Apple HAP):\n> \n> const struct mgos_dns_sd_txt_entry gizmo_txt[] = {\n>     {.key = \"c#\", .value = MG_MK_STR(\"1\")},\n>     {.key = \"ff\", .value = MG_MK_STR(\"0\")},\n>     {.key = \"pv\", .value = MG_MK_STR(\"1.0\")},\n>     {.key = \"id\", .value = MG_MK_STR(\"11:22:33:44:55:66\")},\n>     {.key = \"md\", .value = MG_MK_STR(\"Fancy Gizmo 9000\")},\n>     {.key = \"s#\", .value = MG_MK_STR(\"1\")},\n>     {.key = \"sf\", .value = MG_MK_STR(\"1\")},\n>     {.key = \"ci\", .value = MG_MK_STR(\"8\")},  // Switch\n>     {.key = NULL},\n> };\n> mgos_dns_sd_add_service_instance(\"gizmo9000\", \"_hap._tcp\", 8080, gizmo_txt);\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_dns_sd_remove_service_instance",
    "file": "[mgos_dns_sd.h](https://github.com/mongoose-os-libs/dns-sd/blob/master/include/mgos_dns_sd.h)",
    "doc": "\n```c\nbool mgos_dns_sd_remove_service_instance(\n    const char *instance, const char *proto, int port);\n```\n>  Stop advertising the specified instance. \n",
    "lang": "c"
  },
  {
    "name": "mgos_dns_sd_advertise",
    "file": "[mgos_dns_sd.h](https://github.com/mongoose-os-libs/dns-sd/blob/master/include/mgos_dns_sd.h)",
    "doc": "\n```c\nvoid mgos_dns_sd_advertise(void);\n```\n>  Send a DNS-SD advertisement message now. \n",
    "lang": "c"
  },
  {
    "name": "mgos_dns_sd_goodbye",
    "file": "[mgos_dns_sd.h](https://github.com/mongoose-os-libs/dns-sd/blob/master/include/mgos_dns_sd.h)",
    "doc": "\n```c\nvoid mgos_dns_sd_goodbye(void);\n```\n>  Send a goodbye packet \n",
    "lang": "c"
  },
  {
    "name": "mgos_ds3231_date_time_create",
    "file": "[mgos_ds3231.h](https://github.com/mongoose-os-libs/ds3231/blob/master/include/mgos_ds3231.h)",
    "doc": "\n```c\nstruct mgos_ds3231_date_time *mgos_ds3231_date_time_create();\n```\n> \n> Create a `mgos_ds3231_date_time` structure\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_ds3231_date_time_free",
    "file": "[mgos_ds3231.h](https://github.com/mongoose-os-libs/ds3231/blob/master/include/mgos_ds3231.h)",
    "doc": "\n```c\nvoid mgos_ds3231_date_time_free(struct mgos_ds3231_date_time *dt);\n```\n> \n> Free the `mgos_ds3231_date_time` structure\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_ds3231_date_time_set_date",
    "file": "[mgos_ds3231.h](https://github.com/mongoose-os-libs/ds3231/blob/master/include/mgos_ds3231.h)",
    "doc": "\n```c\nvoid mgos_ds3231_date_time_set_date(struct mgos_ds3231_date_time *dt,\n                                    uint16_t year, uint8_t month, uint8_t day);\n```\n> \n> Set the date part of the `mgos_ds3231_date_time` structure.\n> The `Dow` member is computed by the function\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_ds3231_date_time_set_time",
    "file": "[mgos_ds3231.h](https://github.com/mongoose-os-libs/ds3231/blob/master/include/mgos_ds3231.h)",
    "doc": "\n```c\nvoid mgos_ds3231_date_time_set_time(struct mgos_ds3231_date_time *dt,\n                                    uint8_t hour, uint8_t minute,\n                                    uint8_t second);\n```\n> \n> Set the time part of the `mgos_ds3231_date_time` structure.\n> The `unixtime` member is set by this function. The day/time MUST be UTC\n> `mgos_ds3231_date_time_set_date` should be called before.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_ds3231_date_time_get_unixtime",
    "file": "[mgos_ds3231.h](https://github.com/mongoose-os-libs/ds3231/blob/master/include/mgos_ds3231.h)",
    "doc": "\n```c\ntime_t mgos_ds3231_date_time_get_unixtime(\n    const struct mgos_ds3231_date_time *dt);\n```\n> \n> Get the `unixtime` time part of the `mgos_ds3231_date_time` structure.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_ds3231_date_time_set_unixtime",
    "file": "[mgos_ds3231.h](https://github.com/mongoose-os-libs/ds3231/blob/master/include/mgos_ds3231.h)",
    "doc": "\n```c\nvoid mgos_ds3231_date_time_set_unixtime(struct mgos_ds3231_date_time *dt,\n                                        time_t unixtime);\n```\n> \n> Set the members of `struct mgos_ds3231_date_time` from the provided\n> `unixtime`\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_ds3231_date_time_get_year",
    "file": "[mgos_ds3231.h](https://github.com/mongoose-os-libs/ds3231/blob/master/include/mgos_ds3231.h)",
    "doc": "\n```c\nuint16_t mgos_ds3231_date_time_get_year(struct mgos_ds3231_date_time *dt);\n```\n> \n> \n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_ds3231_create",
    "file": "[mgos_ds3231.h](https://github.com/mongoose-os-libs/ds3231/blob/master/include/mgos_ds3231.h)",
    "doc": "\n```c\nstruct mgos_ds3231 *mgos_ds3231_create(uint8_t addr);\n```\n> \n> Create a `struct mgos_ds3231` structure\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_ds3231_free",
    "file": "[mgos_ds3231.h](https://github.com/mongoose-os-libs/ds3231/blob/master/include/mgos_ds3231.h)",
    "doc": "\n```c\nvoid mgos_ds3231_free(struct mgos_ds3231 *ds);\n```\n> \n> Free a `struct mgos_ds3231` structure\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_ds3231_read",
    "file": "[mgos_ds3231.h](https://github.com/mongoose-os-libs/ds3231/blob/master/include/mgos_ds3231.h)",
    "doc": "\n```c\nconst struct mgos_ds3231_date_time *mgos_ds3231_read(struct mgos_ds3231 *ds);\n```\n> \n> Read the current date and time, returning a structure containing that\n> information.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_ds3231_write",
    "file": "[mgos_ds3231.h](https://github.com/mongoose-os-libs/ds3231/blob/master/include/mgos_ds3231.h)",
    "doc": "\n```c\nbool mgos_ds3231_write(struct mgos_ds3231 *ds,\n                       const struct mgos_ds3231_date_time *date);\n```\n> \n> Set the date and time from the settings in the given structure.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_ds3231_write_unixtime",
    "file": "[mgos_ds3231.h](https://github.com/mongoose-os-libs/ds3231/blob/master/include/mgos_ds3231.h)",
    "doc": "\n```c\nbool mgos_ds3231_write_unixtime(struct mgos_ds3231 *ds, const time_t unixtime);\n```\n> \n> Set the date and time from unixtime.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_ds3231_settimeofday",
    "file": "[mgos_ds3231.h](https://github.com/mongoose-os-libs/ds3231/blob/master/include/mgos_ds3231.h)",
    "doc": "\n```c\nint mgos_ds3231_settimeofday(struct mgos_ds3231 *ds);\n```\n> \n> Sets the system time from the DS3231 data.\n> Assumes DS3231 was previously setup with correct data.\n> \n> Returns 0 if success.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_ds3231_get_temperature_c",
    "file": "[mgos_ds3231.h](https://github.com/mongoose-os-libs/ds3231/blob/master/include/mgos_ds3231.h)",
    "doc": "\n```c\nfloat mgos_ds3231_get_temperature_c(struct mgos_ds3231 *ds);\n```\n> \n> Get the temperature accurate to within 0.25 Celsius\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_ds3231_get_temperature_f",
    "file": "[mgos_ds3231.h](https://github.com/mongoose-os-libs/ds3231/blob/master/include/mgos_ds3231.h)",
    "doc": "\n```c\nfloat mgos_ds3231_get_temperature_f(struct mgos_ds3231 *ds);\n```\n> \n> Get the temperature in Fahrenheit\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_ds3231_disable_alarms",
    "file": "[mgos_ds3231.h](https://github.com/mongoose-os-libs/ds3231/blob/master/include/mgos_ds3231.h)",
    "doc": "\n```c\nbool mgos_ds3231_disable_alarms(struct mgos_ds3231 *ds);\n```\n> * Disable any existing alarm settings.\n> \n>  @return Success True/False\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_ds3231_check_alarms",
    "file": "[mgos_ds3231.h](https://github.com/mongoose-os-libs/ds3231/blob/master/include/mgos_ds3231.h)",
    "doc": "\n```c\nuint8_t mgos_ds3231_check_alarms(struct mgos_ds3231 *ds);\n```\n> \n> Determine if an alarm has triggered, also clears the alarm if so.\n> \n>  Returns 0 for no alarm, 1 for Alarm 1, 2 for Alarm 2, and 3 for both alarms\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_ds3231_check_stopflag",
    "file": "[mgos_ds3231.h](https://github.com/mongoose-os-libs/ds3231/blob/master/include/mgos_ds3231.h)",
    "doc": "\n```c\nuint8_t mgos_ds3231_check_stopflag(struct mgos_ds3231 *ds, int clear);\n```\n> \n> Determine if the oscillator stop flag is set\n> \n>  Returns the flag status\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_ds3231_set_alarm",
    "file": "[mgos_ds3231.h](https://github.com/mongoose-os-libs/ds3231/blob/master/include/mgos_ds3231.h)",
    "doc": "\n```c\nuint8_t mgos_ds3231_set_alarm(struct mgos_ds3231 *ds,\n                              const struct mgos_ds3231_date_time *alarm_date,\n                              uint8_t alarm_mode);\n```\n> \n> Sets an alarm, the alarm will pull the SQW pin low (you can monitor with an\n> interrupt).\n> \n>  `alarm_date` The date/time for the alarm, as appropriate for the alarm mode\n> (example, for\n>    ALARM_MATCH_SECOND then alarm_date.Second will be the matching criteria).\n> \n>  `alarm_mode` the mode of the alarm, from the following...\n> \n>    MGOS_DS3231_ALARM_EVERY_SECOND\n>    MGOS_DS3231_ALARM_MATCH_SECOND\n>    MGOS_DS3231_ALARM_MATCH_SECOND_MINUTE\n>    MGOS_DS3231_ALARM_MATCH_SECOND_MINUTE_HOUR\n>    MGOS_DS3231_ALARM_MATCH_SECOND_MINUTE_HOUR_DATE\n>    MGOS_DS3231_ALARM_MATCH_SECOND_MINUTE_HOUR_DOW\n> \n>    MGOS_DS3231_ALARM_EVERY_MINUTE\n>    MGOS_DS3231_ALARM_MATCH_MINUTE\n>    MGOS_DS3231_ALARM_MATCH_MINUTE_HOUR\n>    MGOS_DS3231_ALARM_MATCH_MINUTE_HOUR_DATE\n>    MGOS_DS3231_ALARM_MATCH_MINUTE_HOUR_DOW\n> \n>    MGOS_DS3231_ALARM_HOURLY\n>    MGOS_DS3231_ALARM_DAILY\n>    MGOS_DS3231_ALARM_WEEKLY\n>    MGOS_DS3231_ALARM_MONTHLY\n> \n>  \n",
    "lang": "c"
  },
  {
    "name": "DS3231DateTime.create()",
    "file": "[api_ds3231.js](https://github.com/mongoose-os-libs/ds3231/blob/master/mjs_fs/api_ds3231.js)",
    "doc": "\n```javascript\nDS3231DateTime.create()\n```\nCreates a DS3231DateTime instance to be used for reading/wrtting data\nfrom/to DS3231.\nReturn value: an object with the methods described below.\n",
    "lang": "js"
  },
  {
    "name": "dsData.free()",
    "file": "[api_ds3231.js](https://github.com/mongoose-os-libs/ds3231/blob/master/mjs_fs/api_ds3231.js)",
    "doc": "\n```javascript\ndsData.free()\n```\nFrees a DS3231DateTime instance.\nNo methods can be called on this instance after that.\nReturn value: none.\n",
    "lang": "js"
  },
  {
    "name": "DS3231.createI2C(address)",
    "file": "[api_ds3231.js](https://github.com/mongoose-os-libs/ds3231/blob/master/mjs_fs/api_ds3231.js)",
    "doc": "\n```javascript\nDS3231.createI2C(address)\n```\nCreates a DS3231 instance on the I2C bus with the given address `address`.\nReturn value: an object with the methods described below.\n",
    "lang": "js"
  },
  {
    "name": "rtc.free()",
    "file": "[api_ds3231.js](https://github.com/mongoose-os-libs/ds3231/blob/master/mjs_fs/api_ds3231.js)",
    "doc": "\n```javascript\nrtc.free()\n```\nFrees the  DS3231 instance.\nNo methods can be called on this instance after that.\nReturn value: none.\n",
    "lang": "js"
  },
  {
    "name": "rtc.read()",
    "file": "[api_ds3231.js](https://github.com/mongoose-os-libs/ds3231/blob/master/mjs_fs/api_ds3231.js)",
    "doc": "\n```javascript\nrtc.read()\n```\nReads date/time from the RTC\nReturns a DS3231DateTime struct.\n",
    "lang": "js"
  },
  {
    "name": "rtc.write(dt)",
    "file": "[api_ds3231.js](https://github.com/mongoose-os-libs/ds3231/blob/master/mjs_fs/api_ds3231.js)",
    "doc": "\n```javascript\nrtc.write(dt)\n```\nWrites a DS3231DateTime structure\nReturns `true` on success\n",
    "lang": "js"
  },
  {
    "name": "rtc.writeUnixtime(unixtime)",
    "file": "[api_ds3231.js](https://github.com/mongoose-os-libs/ds3231/blob/master/mjs_fs/api_ds3231.js)",
    "doc": "\n```javascript\nrtc.writeUnixtime(unixtime)\n```\nSets the date/time from a `unixtime`\nReturns `true` on success\n",
    "lang": "js"
  },
  {
    "name": "rtc.getTemperatureC()",
    "file": "[api_ds3231.js](https://github.com/mongoose-os-libs/ds3231/blob/master/mjs_fs/api_ds3231.js)",
    "doc": "\n```javascript\nrtc.getTemperatureC()\n```\nReturn the temperature in Celsius\n",
    "lang": "js"
  },
  {
    "name": "rtc.getTemperatureF()",
    "file": "[api_ds3231.js](https://github.com/mongoose-os-libs/ds3231/blob/master/mjs_fs/api_ds3231.js)",
    "doc": "\n```javascript\nrtc.getTemperatureF()\n```\nReturn the temperature in Fahrenheit\n",
    "lang": "js"
  },
  {
    "name": "rtc.disableAlarms()",
    "file": "[api_ds3231.js](https://github.com/mongoose-os-libs/ds3231/blob/master/mjs_fs/api_ds3231.js)",
    "doc": "\n```javascript\nrtc.disableAlarms()\n```\nDisable alarms\nReturns `true` on success\n",
    "lang": "js"
  },
  {
    "name": "rtc.checkAlarms()",
    "file": "[api_ds3231.js](https://github.com/mongoose-os-libs/ds3231/blob/master/mjs_fs/api_ds3231.js)",
    "doc": "\n```javascript\nrtc.checkAlarms()\n```\nDisable alarms\nReturns:\n 0 if no alarm\n 1 if Alarm1 was triggered\n 2 if Alarm2 was triggered\n 3 if both alarms were triggered\n",
    "lang": "js"
  },
  {
    "name": "rtc.checkStopFlag()",
    "file": "[api_ds3231.js](https://github.com/mongoose-os-libs/ds3231/blob/master/mjs_fs/api_ds3231.js)",
    "doc": "\n```javascript\nrtc.checkStopFlag()\n```\nCheck the OSF bit\nReturns:\n the oscillator stop flag bit\n",
    "lang": "js"
  },
  {
    "name": "rtc.setAlarm(alarm)",
    "file": "[api_ds3231.js](https://github.com/mongoose-os-libs/ds3231/blob/master/mjs_fs/api_ds3231.js)",
    "doc": "\n```javascript\nrtc.setAlarm(alarm)\n```\nSet alarm\n`dt` - a DS3231DateTime structure\n`mode` - an alarm mode selected from the ALARM_ constants\nReturns `true` on success\n",
    "lang": "js"
  },
  {
    "name": "rtc.setTimeOfDay()",
    "file": "[api_ds3231.js](https://github.com/mongoose-os-libs/ds3231/blob/master/mjs_fs/api_ds3231.js)",
    "doc": "\n```javascript\nrtc.setTimeOfDay()\n```\nSet system time\nReturns 0 on success\n",
    "lang": "js"
  },
  {
    "name": "TouchPad.GPIO",
    "file": "[api_esp32_touchpad.js](https://github.com/mongoose-os-libs/esp32-touchpad/blob/master/mjs_fs/api_esp32_touchpad.js)",
    "doc": "\n```javascript\nTouchPad.GPIO\n```\nHandy map of GPIO to touch sensor number. Touch sensor number is a number\nfrom 0 to 9.\n",
    "lang": "js"
  },
  {
    "name": "TouchPad.init()",
    "file": "[api_esp32_touchpad.js](https://github.com/mongoose-os-libs/esp32-touchpad/blob/master/mjs_fs/api_esp32_touchpad.js)",
    "doc": "\n```javascript\nTouchPad.init()\n```\nInitialize touch pad module.\nReturn value: 0 in case of success, non-zero otherwise.\n",
    "lang": "js"
  },
  {
    "name": "TouchPad.deinit()",
    "file": "[api_esp32_touchpad.js](https://github.com/mongoose-os-libs/esp32-touchpad/blob/master/mjs_fs/api_esp32_touchpad.js)",
    "doc": "\n```javascript\nTouchPad.deinit()\n```\nUninstall touch pad driver.\nReturn value: 0 in case of success, non-zero otherwise.\n",
    "lang": "js"
  },
  {
    "name": "TouchPad.config(touch_num, threshold)",
    "file": "[api_esp32_touchpad.js](https://github.com/mongoose-os-libs/esp32-touchpad/blob/master/mjs_fs/api_esp32_touchpad.js)",
    "doc": "\n```javascript\nTouchPad.config(touch_num, threshold)\n```\nConfigure touch pad interrupt threshold.\n`touch_num` is a touchpad index (a number from 0 to 9), `threshold` is an interrupt threshold\nReturn value: 0 in case of success, non-zero otherwise.\n",
    "lang": "js"
  },
  {
    "name": "TouchPad.read(touch_num)",
    "file": "[api_esp32_touchpad.js](https://github.com/mongoose-os-libs/esp32-touchpad/blob/master/mjs_fs/api_esp32_touchpad.js)",
    "doc": "\n```javascript\nTouchPad.read(touch_num)\n```\nReturn touch sensor counter value or -1 in case of a failure. `touch_num`\nis a touchpad index (a number from 0 to 9)\n\nEach touch sensor has a counter to count the number of charge/discharge\ncycles.  When the pad is not 'touched', we can get a number of the\ncounter.  When the pad is 'touched', the value in counter will get smaller\nbecause of the larger equivalent capacitance.  User can use this function\nto determine the interrupt trigger threshold.\n",
    "lang": "js"
  },
  {
    "name": "TouchPad.readFiltered(touch_num)",
    "file": "[api_esp32_touchpad.js](https://github.com/mongoose-os-libs/esp32-touchpad/blob/master/mjs_fs/api_esp32_touchpad.js)",
    "doc": "\n```javascript\nTouchPad.readFiltered(touch_num)\n```\nGet filtered touch sensor counter value by IIR filter, or -1 in case of a\nfailure. NOTE: `TouchPad.filterStart()` has to be called before this\nfunction.  `touch_num` is a touchpad index (a number from 0 to 9).\n",
    "lang": "js"
  },
  {
    "name": "TouchPad.isrRegister(handler, userdata)",
    "file": "[api_esp32_touchpad.js](https://github.com/mongoose-os-libs/esp32-touchpad/blob/master/mjs_fs/api_esp32_touchpad.js)",
    "doc": "\n```javascript\nTouchPad.isrRegister(handler, userdata)\n```\nRegister touchpad ISR. The handler will be attached to the same CPU core\nthat this function is running on. Handler is a function like\n`function(status, userdata){ /* ... */ }`, `status` is a number\nrepresenting which pads are \"touched\".\nReturn value: 0 in case of success, non-zero otherwise.\n",
    "lang": "js"
  },
  {
    "name": "TouchPad.isrDeregister()",
    "file": "[api_esp32_touchpad.js](https://github.com/mongoose-os-libs/esp32-touchpad/blob/master/mjs_fs/api_esp32_touchpad.js)",
    "doc": "\n```javascript\nTouchPad.isrDeregister()\n```\nDeregister touchpad ISR previously registered with\n`TouchPad.isrRegister()`.  Return value: 0 in case of success, non-zero\notherwise.\n",
    "lang": "js"
  },
  {
    "name": "TouchPad.intrEnable()",
    "file": "[api_esp32_touchpad.js](https://github.com/mongoose-os-libs/esp32-touchpad/blob/master/mjs_fs/api_esp32_touchpad.js)",
    "doc": "\n```javascript\nTouchPad.intrEnable()\n```\nEnable touchpad interrupt. Return value: 0.\n",
    "lang": "js"
  },
  {
    "name": "TouchPad.intrDisable()",
    "file": "[api_esp32_touchpad.js](https://github.com/mongoose-os-libs/esp32-touchpad/blob/master/mjs_fs/api_esp32_touchpad.js)",
    "doc": "\n```javascript\nTouchPad.intrDisable()\n```\nDisable touchpad interrupt. Return value: 0.\n",
    "lang": "js"
  },
  {
    "name": "TouchPad.setMeasTime(sleep_cycle, meas_cycle)",
    "file": "[api_esp32_touchpad.js](https://github.com/mongoose-os-libs/esp32-touchpad/blob/master/mjs_fs/api_esp32_touchpad.js)",
    "doc": "\n```javascript\nTouchPad.setMeasTime(sleep_cycle, meas_cycle)\n```\nSet touch sensor measurement and sleep time.\nThe touch sensor will sleep after each measurement.  `sleep_cycle` determines\nthe interval between each measurement:  `t_sleep = sleep_cycle / (RTC_SLOW_CLK frequency)`.\n`meas_cycle` is the duration of the touch sensor measurement.\n`t_meas = meas_cycle / 8M`, the maximum measure time is `0xffff / 8M = 8.19 ms`\nReturn value: 0 in case of success, non-zero otherwise.\n",
    "lang": "js"
  },
  {
    "name": "TouchPad.getMeasTimeSleepCycle()",
    "file": "[api_esp32_touchpad.js](https://github.com/mongoose-os-libs/esp32-touchpad/blob/master/mjs_fs/api_esp32_touchpad.js)",
    "doc": "\n```javascript\nTouchPad.getMeasTimeSleepCycle()\n```\nReturn sleep cycle (previously set with `TouchPad.setMeasTime()`), or -1 in\ncase of a failure.\n",
    "lang": "js"
  },
  {
    "name": "TouchPad.getMeasTimeMeasCycle()",
    "file": "[api_esp32_touchpad.js](https://github.com/mongoose-os-libs/esp32-touchpad/blob/master/mjs_fs/api_esp32_touchpad.js)",
    "doc": "\n```javascript\nTouchPad.getMeasTimeMeasCycle()\n```\nReturn duration of the touch sensor measurement (previously set with\n`TouchPad.setMeasTime()`), or -1 in case of a failure.\n",
    "lang": "js"
  },
  {
    "name": "TouchPad.setVoltage(refh, refl, atten)",
    "file": "[api_esp32_touchpad.js](https://github.com/mongoose-os-libs/esp32-touchpad/blob/master/mjs_fs/api_esp32_touchpad.js)",
    "doc": "\n```javascript\nTouchPad.setVoltage(refh, refl, atten)\n```\nSet touch sensor reference voltage, if the voltage gap between high and\nlow reference voltage get less, the charging and discharging time would be\nfaster; accordingly, the counter value would be larger.  In the case of\ndetecting very slight change of capacitance, we can narrow down the gap so\nas to increase the sensitivity. On the other hand, narrow voltage gap\nwould also introduce more noise, but we can use a software filter to\npre-process the counter value.\n\n`refh` is the value of `DREFH`, one of the following:\n- `TouchPad.HVOLT_KEEP`\n- `TouchPad.HVOLT_2V4`\n- `TouchPad.HVOLT_2V5`\n- `TouchPad.HVOLT_2V6`\n- `TouchPad.HVOLT_2V7`\n\n`refl` is the value os `DREFL`, one of the following:\n- `TouchPad.LVOLT_KEEP`\n- `TouchPad.LVOLT_0V5`\n- `TouchPad.LVOLT_0V6`\n- `TouchPad.LVOLT_0V7`\n- `TouchPad.LVOLT_0V8`\n\n`atten` is the attenuation of `DREFH`, one of the following:\n- `TouchPad.HVOLT_ATTEN_KEEP`\n- `TouchPad.HVOLT_ATTEN_1V5`\n- `TouchPad.HVOLT_ATTEN_1V`\n- `TouchPad.HVOLT_ATTEN_0V5`\n- `TouchPad.HVOLT_ATTEN_0V`\n\nReturn value: 0 in case of success, non-zero otherwise.\n",
    "lang": "js"
  },
  {
    "name": "TouchPad.getVoltageRefH()",
    "file": "[api_esp32_touchpad.js](https://github.com/mongoose-os-libs/esp32-touchpad/blob/master/mjs_fs/api_esp32_touchpad.js)",
    "doc": "\n```javascript\nTouchPad.getVoltageRefH()\n```\nGet touch sensor reference voltage `refh` (previously set with\n`TouchPad.setVoltage()`), or -1 in case of a failure.\n",
    "lang": "js"
  },
  {
    "name": "TouchPad.getVoltageRefL()",
    "file": "[api_esp32_touchpad.js](https://github.com/mongoose-os-libs/esp32-touchpad/blob/master/mjs_fs/api_esp32_touchpad.js)",
    "doc": "\n```javascript\nTouchPad.getVoltageRefL()\n```\nGet touch sensor reference voltage `refl` (previously set with\n`TouchPad.setVoltage()`), or -1 in case of a failure.\n",
    "lang": "js"
  },
  {
    "name": "TouchPad.getVoltageAtten()",
    "file": "[api_esp32_touchpad.js](https://github.com/mongoose-os-libs/esp32-touchpad/blob/master/mjs_fs/api_esp32_touchpad.js)",
    "doc": "\n```javascript\nTouchPad.getVoltageAtten()\n```\nGet touch sensor attenuation of `DREFH` (previously set with\n`TouchPad.setVoltage()`), or -1 in case of a failure.\n",
    "lang": "js"
  },
  {
    "name": "TouchPad.setCntMode(touch_num, slope, opt)",
    "file": "[api_esp32_touchpad.js](https://github.com/mongoose-os-libs/esp32-touchpad/blob/master/mjs_fs/api_esp32_touchpad.js)",
    "doc": "\n```javascript\nTouchPad.setCntMode(touch_num, slope, opt)\n```\nSet touch sensor charge/discharge speed for each pad.\n\n`touch_num` is a touchpad index (a number from 0 to 9), `slope` is a\ncharge/discharge speed, `opt` is the initial voltage, one of the following:\n- `TouchPad.PAD_TIE_OPT_LOW`\n- `TouchPad.PAD_TIE_OPT_HIGH`\n\nIf `slope` is 0, the counter would always be zero.\nIf `slope` is 1, the charging and discharging would be slow, accordingly,\nthe counter value would be small.\nIf `slope` is set 7, which is the maximum value, the charging and\ndischarging would be fast, accordingly, the counter value would be larger.\nReturn value: 0 in case of success, non-zero otherwise.\n",
    "lang": "js"
  },
  {
    "name": "TouchPad.getCntModeSlope(touch_num)",
    "file": "[api_esp32_touchpad.js](https://github.com/mongoose-os-libs/esp32-touchpad/blob/master/mjs_fs/api_esp32_touchpad.js)",
    "doc": "\n```javascript\nTouchPad.getCntModeSlope(touch_num)\n```\nGet \"slope\": a charge/discharge speed previously set with\n`TouchPad.setCntMode()`, or -1 in case of a failure.\n",
    "lang": "js"
  },
  {
    "name": "TouchPad.getCntModeOpt(touch_num)",
    "file": "[api_esp32_touchpad.js](https://github.com/mongoose-os-libs/esp32-touchpad/blob/master/mjs_fs/api_esp32_touchpad.js)",
    "doc": "\n```javascript\nTouchPad.getCntModeOpt(touch_num)\n```\nGet initial voltage previously set with `TouchPad.setCntMode()`, or -1 in\ncase of a failure.\n`touch_num` is a touchpad index (a number from 0 to 9).\n",
    "lang": "js"
  },
  {
    "name": "TouchPad.ioInit(touch_num)",
    "file": "[api_esp32_touchpad.js](https://github.com/mongoose-os-libs/esp32-touchpad/blob/master/mjs_fs/api_esp32_touchpad.js)",
    "doc": "\n```javascript\nTouchPad.ioInit(touch_num)\n```\nInitialize touch pad GPIO.\n`touch_num` is a touchpad index (a number from 0 to 9).\nReturn value: 0 in case of success, non-zero otherwise.\n",
    "lang": "js"
  },
  {
    "name": "TouchPad.setFSMMode(mode)",
    "file": "[api_esp32_touchpad.js](https://github.com/mongoose-os-libs/esp32-touchpad/blob/master/mjs_fs/api_esp32_touchpad.js)",
    "doc": "\n```javascript\nTouchPad.setFSMMode(mode)\n```\nSet touch sensor FSM mode, the test action can be triggered by the timer,\nas well as by the software. `mode` can be one of the following:\n- `TouchPad.FSM_MODE_TIMER`\n- `TouchPad.FSM_MODE_SW`\nReturn value: 0 in case of success, non-zero otherwise.\n",
    "lang": "js"
  },
  {
    "name": "TouchPad.getFSMMode()",
    "file": "[api_esp32_touchpad.js](https://github.com/mongoose-os-libs/esp32-touchpad/blob/master/mjs_fs/api_esp32_touchpad.js)",
    "doc": "\n```javascript\nTouchPad.getFSMMode()\n```\nGet FSM mode previously set with `TouchPad.setFSMMode()`, or -1 in case of\na failure.\n",
    "lang": "js"
  },
  {
    "name": "TouchPad.swStart()",
    "file": "[api_esp32_touchpad.js](https://github.com/mongoose-os-libs/esp32-touchpad/blob/master/mjs_fs/api_esp32_touchpad.js)",
    "doc": "\n```javascript\nTouchPad.swStart()\n```\nTrigger a touch sensor measurement, only support in `FSM_MODE_SW` mode of\nFSM.\nReturn value: 0 in case of success, non-zero otherwise.\n",
    "lang": "js"
  },
  {
    "name": "TouchPad.setThresh(touch_num, threshold)",
    "file": "[api_esp32_touchpad.js](https://github.com/mongoose-os-libs/esp32-touchpad/blob/master/mjs_fs/api_esp32_touchpad.js)",
    "doc": "\n```javascript\nTouchPad.setThresh(touch_num, threshold)\n```\nSet touch sensor interrupt threshold.\n`touch_num` is a touchpad index (a number from 0 to 9), `threshold` is a\nthreshold of touchpad count; refer to `TouchPad.setTriggerMode()` to see\nhow to set trigger mode.\nReturn value: 0 in case of success, non-zero otherwise.\n",
    "lang": "js"
  },
  {
    "name": "TouchPad.getThresh(touch_num)",
    "file": "[api_esp32_touchpad.js](https://github.com/mongoose-os-libs/esp32-touchpad/blob/master/mjs_fs/api_esp32_touchpad.js)",
    "doc": "\n```javascript\nTouchPad.getThresh(touch_num)\n```\nGet touch sensor interrupt threshold previously set with\n`TouchPad.setThresh()`, or -1 in case of a failure.\n`touch_num` is a touchpad index (a number from 0 to 9).\nReturn value: 0 in case of success, non-zero otherwise.\n",
    "lang": "js"
  },
  {
    "name": "TouchPad.setTriggerMode(mode)",
    "file": "[api_esp32_touchpad.js](https://github.com/mongoose-os-libs/esp32-touchpad/blob/master/mjs_fs/api_esp32_touchpad.js)",
    "doc": "\n```javascript\nTouchPad.setTriggerMode(mode)\n```\nSet touch sensor interrupt trigger mode, one of the following:\n- `TouchPad.TRIGGER_BELOW`\n- `TouchPad.TRIGGER_ABOVE`\n\nInterrupt can be triggered either when counter result is less than\nthreshold, or when counter result is more than threshold.\n\nReturn value: 0 in case of success, non-zero otherwise.\n",
    "lang": "js"
  },
  {
    "name": "TouchPad.getTriggerMode()",
    "file": "[api_esp32_touchpad.js](https://github.com/mongoose-os-libs/esp32-touchpad/blob/master/mjs_fs/api_esp32_touchpad.js)",
    "doc": "\n```javascript\nTouchPad.getTriggerMode()\n```\nGet touch sensor interrupt trigger mode previously set with\n`TouchPad.setTriggerMode()`, or -1 in case of a failure.\nReturn value: 0 in case of success, non-zero otherwise.\n",
    "lang": "js"
  },
  {
    "name": "TouchPad.setTriggerSource(src)",
    "file": "[api_esp32_touchpad.js](https://github.com/mongoose-os-libs/esp32-touchpad/blob/master/mjs_fs/api_esp32_touchpad.js)",
    "doc": "\n```javascript\nTouchPad.setTriggerSource(src)\n```\nSet touch sensor interrupt trigger source `src`, one of the following:\n- `TouchPad.TRIGGER_SOURCE_BOTH`\n- `TouchPad.TRIGGER_SOURCE_SET1`\n\nThere are two sets of touch signals.  Set1 and set2 can be mapped to\nseveral touch signals. Either set will be triggered if at least one of its\ntouch signal is 'touched'. The interrupt can be configured to be generated\nif set1 is triggered, or only if both sets are triggered.\n\nReturn value: 0 in case of success, non-zero otherwise.\n",
    "lang": "js"
  },
  {
    "name": "TouchPad.getTriggerSource()",
    "file": "[api_esp32_touchpad.js](https://github.com/mongoose-os-libs/esp32-touchpad/blob/master/mjs_fs/api_esp32_touchpad.js)",
    "doc": "\n```javascript\nTouchPad.getTriggerSource()\n```\nGet touch sensor interrupt trigger source previously set with\n`TouchPad.setTriggerSource()`, or -1 in case of a failure.\nReturn value: 0 in case of success, non-zero otherwise.\n",
    "lang": "js"
  },
  {
    "name": "TouchPad.setGroupMask(set1_mask, set2_mask, en_mask)",
    "file": "[api_esp32_touchpad.js](https://github.com/mongoose-os-libs/esp32-touchpad/blob/master/mjs_fs/api_esp32_touchpad.js)",
    "doc": "\n```javascript\nTouchPad.setGroupMask(set1_mask, set2_mask, en_mask)\n```\nSet touch sensor group mask.  Touch pad module has two sets of signals,\n'Touched' signal is triggered only if at least one of touch pad in this\ngroup is \"touched\".  This function will set the register bits according to\nthe given bitmask.\n\n`set1_mask` is a bitmask of touch sensor signal group1, it's a 10-bit value.\n`set2_mask` is a bitmask of touch sensor signal group2, it's a 10-bit value.\n`en_mask` is a bitmask of touch sensor work enable, it's a 10-bit value.\n\nReturn value: 0 in case of success, non-zero otherwise.\n",
    "lang": "js"
  },
  {
    "name": "TouchPad.getGroupMaskSet1()",
    "file": "[api_esp32_touchpad.js](https://github.com/mongoose-os-libs/esp32-touchpad/blob/master/mjs_fs/api_esp32_touchpad.js)",
    "doc": "\n```javascript\nTouchPad.getGroupMaskSet1()\n```\nGet set1 mask previously set with `TouchPad.setGroupMask()`, or -1 in case\nof a failure.\n",
    "lang": "js"
  },
  {
    "name": "TouchPad.getGroupMaskSet2()",
    "file": "[api_esp32_touchpad.js](https://github.com/mongoose-os-libs/esp32-touchpad/blob/master/mjs_fs/api_esp32_touchpad.js)",
    "doc": "\n```javascript\nTouchPad.getGroupMaskSet2()\n```\nGet set2 mask previously set with `TouchPad.setGroupMask()`, or -1 in case\nof a failure.\n",
    "lang": "js"
  },
  {
    "name": "TouchPad.getGroupMaskEn()",
    "file": "[api_esp32_touchpad.js](https://github.com/mongoose-os-libs/esp32-touchpad/blob/master/mjs_fs/api_esp32_touchpad.js)",
    "doc": "\n```javascript\nTouchPad.getGroupMaskEn()\n```\nGet mask of enabled sensors previously set with `TouchPad.setGroupMask()`,\nor -1 in case of a failure.\n",
    "lang": "js"
  },
  {
    "name": "TouchPad.clearStatus()",
    "file": "[api_esp32_touchpad.js](https://github.com/mongoose-os-libs/esp32-touchpad/blob/master/mjs_fs/api_esp32_touchpad.js)",
    "doc": "\n```javascript\nTouchPad.clearStatus()\n```\nClear touch status register.\nReturn value: 0 in case of success, non-zero otherwise.\n",
    "lang": "js"
  },
  {
    "name": "TouchPad.getStatus()",
    "file": "[api_esp32_touchpad.js](https://github.com/mongoose-os-libs/esp32-touchpad/blob/master/mjs_fs/api_esp32_touchpad.js)",
    "doc": "\n```javascript\nTouchPad.getStatus()\n```\nReturn status: a number representing which pads are \"touched\".\n",
    "lang": "js"
  },
  {
    "name": "TouchPad.setFilterPeriod(period_ms)",
    "file": "[api_esp32_touchpad.js](https://github.com/mongoose-os-libs/esp32-touchpad/blob/master/mjs_fs/api_esp32_touchpad.js)",
    "doc": "\n```javascript\nTouchPad.setFilterPeriod(period_ms)\n```\nSet touch pad filter calibration period, in ms.  Need to call\n`TouchPad.filterStart()` before all touch filter APIs.\nReturn value: 0 in case of success, non-zero otherwise.\n",
    "lang": "js"
  },
  {
    "name": "TouchPad.getFilterPeriod(period_ms)",
    "file": "[api_esp32_touchpad.js](https://github.com/mongoose-os-libs/esp32-touchpad/blob/master/mjs_fs/api_esp32_touchpad.js)",
    "doc": "\n```javascript\nTouchPad.getFilterPeriod(period_ms)\n```\nGet touch pad filter calibration period in ms previously set with\n`TouchPad.setFilterPeriod()`, or -1 in case of a failure.\n",
    "lang": "js"
  },
  {
    "name": "TouchPad.filterStart(filter_period_ms)",
    "file": "[api_esp32_touchpad.js](https://github.com/mongoose-os-libs/esp32-touchpad/blob/master/mjs_fs/api_esp32_touchpad.js)",
    "doc": "\n```javascript\nTouchPad.filterStart(filter_period_ms)\n```\nStart a filter to process the noise in order to prevent false triggering\nwhen detecting slight change of capacitance. This function must be called\nbefore any other filter API functions.\n\nIf filter is not initialized, this function will initialize the filter\nwith given period.  If filter is already initialized, it will update the\nfilter period.\n\nReturn value: 0 in case of success, non-zero otherwise.\n",
    "lang": "js"
  },
  {
    "name": "TouchPad.filterStop()",
    "file": "[api_esp32_touchpad.js](https://github.com/mongoose-os-libs/esp32-touchpad/blob/master/mjs_fs/api_esp32_touchpad.js)",
    "doc": "\n```javascript\nTouchPad.filterStop()\n```\nStop touch pad filter, started before with `TouchPad.filterStart()`.\nReturn value: 0 in case of success, non-zero otherwise.\n",
    "lang": "js"
  },
  {
    "name": "TouchPad.filterDelete()",
    "file": "[api_esp32_touchpad.js](https://github.com/mongoose-os-libs/esp32-touchpad/blob/master/mjs_fs/api_esp32_touchpad.js)",
    "doc": "\n```javascript\nTouchPad.filterDelete()\n```\nDelete touch pad filter driver (activated before with\n`TouchPad.filterStart()`) and release the memory.\nReturn value: 0 in case of success, non-zero otherwise.\n",
    "lang": "js"
  },
  {
    "name": "(",
    "file": "[FreeRTOSConfigCommon.h](https://github.com/mongoose-os-libs/freertos/blob/master/include/FreeRTOSConfigCommon.h)",
    "doc": "\n```c\n#define configTICK_RATE_HZ ((TickType_t) 100)\n#define configUSE_NEWLIB_REENTRANT 0\n#define configMINIMAL_STACK_SIZE 256 /* x 4 = 1024 */\n#define configMAX_PRIORITIES 25\n#define configUSE_PREEMPTION 1\n#define configUSE_IDLE_HOOK 0\n#define configUSE_TICK_HOOK 0\n#define configUSE_16_BIT_TICKS 0\n```\n> no_extern_c_check\n",
    "lang": "c"
  },
  {
    "name": "mgos_gcp_is_connected",
    "file": "[mgos_gcp.h](https://github.com/mongoose-os-libs/gcp/blob/master/include/mgos_gcp.h)",
    "doc": "\n```c\nbool mgos_gcp_is_connected(void);\n```\n>  Returns true if GCP connection is up, false otherwise. \n",
    "lang": "c"
  },
  {
    "name": "mgos_gcp_send_event",
    "file": "[mgos_gcp.h](https://github.com/mongoose-os-libs/gcp/blob/master/include/mgos_gcp.h)",
    "doc": "\n```c\nbool mgos_gcp_send_event(const struct mg_str data);\nbool mgos_gcp_send_eventp(const struct mg_str *data);\nbool mgos_gcp_send_eventf(const char *json_fmt, ...);\n```\n> \n> Send a telemetry event to the default topic.\n> \n> Se documentation here:\n> https://cloud.google.com/iot/docs/how-tos/mqtt-bridge#publishing_telemetry_events\n> \n> E.g.: mgos_gcp_send_eventf(\"{foo: %d}\", foo);\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_gcp_send_event_sub",
    "file": "[mgos_gcp.h](https://github.com/mongoose-os-libs/gcp/blob/master/include/mgos_gcp.h)",
    "doc": "\n```c\nbool mgos_gcp_send_event_sub(const struct mg_str subfolder,\n                             const struct mg_str data);\nbool mgos_gcp_send_event_subp(const struct mg_str *subfolder,\n                              const struct mg_str *data);\nbool mgos_gcp_send_event_subf(const char *subfolder, const char *json_fmt, ...);\n```\n> \n> Send a telemetry event to a subfolder topic.\n> \n> E.g.: mgos_gcp_send_event_subf(\"foo_events\", \"{foo: %d}\", foo);\n>  \n",
    "lang": "c"
  },
  {
    "name": "GCP.isConnected()",
    "file": "[api_gcp.js](https://github.com/mongoose-os-libs/gcp/blob/master/mjs_fs/api_gcp.js)",
    "doc": "\n```javascript\nGCP.isConnected()\n```\nReturn value: true if GCP connection is up, false otherwise.\n",
    "lang": "js"
  },
  {
    "name": "mgos_get_sys_http_server",
    "file": "[mgos_http_server.h](https://github.com/mongoose-os-libs/http-server/blob/master/include/mgos_http_server.h)",
    "doc": "\n```c\nstruct mg_connection *mgos_get_sys_http_server(void);\n```\n> \n> Return global listening connection\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_register_http_endpoint",
    "file": "[mgos_http_server.h](https://github.com/mongoose-os-libs/http-server/blob/master/include/mgos_http_server.h)",
    "doc": "\n```c\nvoid mgos_register_http_endpoint(const char *uri_path,\n                                 mg_event_handler_t handler, void *user_data);\n```\n> \n> Register HTTP endpoint handler `handler` on URI `uri_path`\n> \n> Example:\n> ```c\n> static void foo_handler(struct mg_connection *c, int ev, void *p,\n>                         void *user_data) {\n>   (void) p;\n>   if (ev != MG_EV_HTTP_REQUEST) return;\n>   LOG(LL_INFO, (\"Foo requested\"));\n>   mg_send_response_line(c, 200,\n>                         \"Content-Type: text/html\\r\\n\");\n>   mg_printf(c, \"%s\\r\\n\", \"Fooooo\");\n>   c->flags |= (MG_F_SEND_AND_CLOSE | MGOS_F_RELOAD_CONFIG);\n>   (void) user_data;\n> }\n> \n> // Somewhere else:\n> mgos_register_http_endpoint(\"/foo/\", foo_handler, NULL);\n> ```\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_register_http_endpoint_opt",
    "file": "[mgos_http_server.h](https://github.com/mongoose-os-libs/http-server/blob/master/include/mgos_http_server.h)",
    "doc": "\n```c\nvoid mgos_register_http_endpoint_opt(const char *uri_path,\n                                     mg_event_handler_t handler,\n                                     struct mg_http_endpoint_opts opts);\n```\n> \n> Like `mgos_register_http_endpoint()`, but additionally takes `struct\n> mg_http_endpoint_opts opts`\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_http_server_set_document_root",
    "file": "[mgos_http_server.h](https://github.com/mongoose-os-libs/http-server/blob/master/include/mgos_http_server.h)",
    "doc": "\n```c\nvoid mgos_http_server_set_document_root(const char *document_root);\n```\n> \n> Set document root to serve static content from. Setting it to NULL disables\n> static server (404 will be returned).\n>  \n",
    "lang": "c"
  },
  {
    "name": "_read",
    "file": "[mgos_htu21df.h](https://github.com/mongoose-os-libs/htu21df-i2c/blob/master/include/mgos_htu21df.h)",
    "doc": "\n```c\nuint32_t read;                 // calls to _read()\n  uint32_t read_success;         // successful _read()\n  uint32_t read_success_cached;  // calls to _read() which were cached\n  // Note: read_errors := read - read_success - read_success_cached\n  double   read_success_usecs;   // time spent in successful uncached _read()\n};\n```\n> value of mg_time() upon last call to _read()\n",
    "lang": "c"
  },
  {
    "name": "mgos_htu21df_create",
    "file": "[mgos_htu21df.h](https://github.com/mongoose-os-libs/htu21df-i2c/blob/master/include/mgos_htu21df.h)",
    "doc": "\n```c\nstruct mgos_htu21df *mgos_htu21df_create(struct mgos_i2c *i2c, uint8_t i2caddr);\n```\n> \n> Initialize a HTU21DF on the I2C bus `i2c` at address specified in `i2caddr`\n> parameter (default HTU21DF is on address 0x40). The sensor will be polled for\n> validity, upon success a new `struct mgos_htu21df` is allocated and\n> returned. If the device could not be found, NULL is returned.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_htu21df_destroy",
    "file": "[mgos_htu21df.h](https://github.com/mongoose-os-libs/htu21df-i2c/blob/master/include/mgos_htu21df.h)",
    "doc": "\n```c\nvoid mgos_htu21df_destroy(struct mgos_htu21df **sensor);\n```\n> \n> Destroy the data structure associated with a HTU21DF device. The reference\n> to the pointer of the `struct mgos_htu21df` has to be provided, and upon\n> successful destruction, its associated memory will be freed and the pointer\n> set to NULL.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_htu21df_read",
    "file": "[mgos_htu21df.h](https://github.com/mongoose-os-libs/htu21df-i2c/blob/master/include/mgos_htu21df.h)",
    "doc": "\n```c\nbool mgos_htu21df_read(struct mgos_htu21df *sensor);\n```\n> \n> The sensor will be polled for its temperature and humidity data. If the poll\n> has occured in the last `MGOS_HTU21DF_READ_DELAY` seconds, the cached data is\n> used (so as not to repeatedly poll the bus upon subsequent calls).\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_htu21df_getTemperature",
    "file": "[mgos_htu21df.h](https://github.com/mongoose-os-libs/htu21df-i2c/blob/master/include/mgos_htu21df.h)",
    "doc": "\n```c\nfloat mgos_htu21df_getTemperature(struct mgos_htu21df *sensor);\n```\n> \n> The sensor will be polled for its temperature and humidity data. If the poll\n> has occured in the last `MGOS_HTU21DF_READ_DELAY` seconds, the cached data is\n> used (so as not to repeatedly poll the bus upon subsequent calls).\n> \n> The return value is the temperature of the sensor in Celsius, or NAN if no\n> data was found.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_htu21df_getHumidity",
    "file": "[mgos_htu21df.h](https://github.com/mongoose-os-libs/htu21df-i2c/blob/master/include/mgos_htu21df.h)",
    "doc": "\n```c\nfloat mgos_htu21df_getHumidity(struct mgos_htu21df *sensor);\n```\n> \n> The sensor will be polled for its temperature and humidity data. If the poll\n> has occured in the last `MGOS_HTU21DF_READ_DELAY` seconds, the cached data is\n> used (so as not to repeatedly poll the bus upon subsequent calls).\n> \n> The return value is the humidity of the sensor in percent relative humidity,\n> or NAN if no data was found.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_htu21df_getStats",
    "file": "[mgos_htu21df.h](https://github.com/mongoose-os-libs/htu21df-i2c/blob/master/include/mgos_htu21df.h)",
    "doc": "\n```c\nbool mgos_htu21df_getStats(struct mgos_htu21df *sensor, struct mgos_htu21df_stats *stats);\n```\n> \n> Returns the running statistics on the sensor interaction, the user provides\n> a pointer to a `struct mgos_htu21df_stats` object, which is filled in by\n> this call.\n> \n> Upon success, true is returned. Otherwise, false is returned, in which case\n> the contents of `stats` is undetermined.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_htu21df_i2c_init",
    "file": "[mgos_htu21df.h](https://github.com/mongoose-os-libs/htu21df-i2c/blob/master/include/mgos_htu21df.h)",
    "doc": "\n```c\nbool mgos_htu21df_i2c_init(void);\n```\n> \n> Initialization function for MGOS -- currently a noop.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_i2c_create",
    "file": "[mgos_i2c.h](https://github.com/mongoose-os-libs/i2c/blob/master/include/mgos_i2c.h)",
    "doc": "\n```c\nstruct mgos_i2c *mgos_i2c_create(const struct mgos_config_i2c *cfg);\n```\n> \n> Initialize I2C master with the given params. Typically clients don't need to\n> do that manually: mgos has a global I2C instance created with the params\n> given in system config, use `mgos_i2c_get_global()` to get the global\n> instance.\n> \n> Example:\n> ```c\n> const struct mgos_config_i2c cfg = {\n>   .enable: true,\n>   .freq: 400,\n>   .debug: 0,\n>   .sda_gpio: 13,\n>   .scl_gpio: 12,\n> };\n> struct mgos_i2c *myi2c = mgos_i2c_create(&cfg);\n> ```\n>  \n",
    "lang": "c"
  },
  {
    "name": "(",
    "file": "[mgos_i2c.h](https://github.com/mongoose-os-libs/i2c/blob/master/include/mgos_i2c.h)",
    "doc": "\n```c\n#define MGOS_I2C_ADDR_CONTINUE ((uint16_t) -1)\n```\n>  If this special address is passed to read or write, START is not generated\n> and address is not put on the bus. It is assumed that this is a continuation\n> of a previous operation which (after read or write with stop = false). \n",
    "lang": "c"
  },
  {
    "name": "mgos_i2c_read",
    "file": "[mgos_i2c.h](https://github.com/mongoose-os-libs/i2c/blob/master/include/mgos_i2c.h)",
    "doc": "\n```c\nbool mgos_i2c_read(struct mgos_i2c *i2c, uint16_t addr, void *data, size_t len,\n                   bool stop);\n```\n> \n> Read specified number of bytes from the specified address.\n> Address should not include the R/W bit. If addr is -1, START is not\n> performed.\n> If |stop| is true, then at the end of the operation bus will be released.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_i2c_write",
    "file": "[mgos_i2c.h](https://github.com/mongoose-os-libs/i2c/blob/master/include/mgos_i2c.h)",
    "doc": "\n```c\nbool mgos_i2c_write(struct mgos_i2c *i2c, uint16_t addr, const void *data,\n                    size_t len, bool stop);\n```\n> \n> Write specified number of bytes from the specified address.\n> Address should not include the R/W bit. If addr is -1, START is not\n> performed.\n> If |stop| is true, then at the end of the operation bus will be released.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_i2c_stop",
    "file": "[mgos_i2c.h](https://github.com/mongoose-os-libs/i2c/blob/master/include/mgos_i2c.h)",
    "doc": "\n```c\nvoid mgos_i2c_stop(struct mgos_i2c *i2c);\n```\n> \n> Release the bus (when left unreleased after read or write).\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_i2c_get_freq",
    "file": "[mgos_i2c.h](https://github.com/mongoose-os-libs/i2c/blob/master/include/mgos_i2c.h)",
    "doc": "\n```c\nint mgos_i2c_get_freq(struct mgos_i2c *i2c);\n```\n> \n> Get I2C interface frequency.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_i2c_set_freq",
    "file": "[mgos_i2c.h](https://github.com/mongoose-os-libs/i2c/blob/master/include/mgos_i2c.h)",
    "doc": "\n```c\nbool mgos_i2c_set_freq(struct mgos_i2c *i2c, int freq);\n```\n> \n> Set I2C interface frequency.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_i2c_read_reg_b",
    "file": "[mgos_i2c.h](https://github.com/mongoose-os-libs/i2c/blob/master/include/mgos_i2c.h)",
    "doc": "\n```c\nint mgos_i2c_read_reg_b(struct mgos_i2c *conn, uint16_t addr, uint8_t reg);\n```\n> \n> Helper for reading 1-byte register `reg` from a device at address `addr`.\n> In case of success return a numeric byte value from 0x00 to 0xff; otherwise\n> return -1.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_i2c_read_reg_w",
    "file": "[mgos_i2c.h](https://github.com/mongoose-os-libs/i2c/blob/master/include/mgos_i2c.h)",
    "doc": "\n```c\nint mgos_i2c_read_reg_w(struct mgos_i2c *conn, uint16_t addr, uint8_t reg);\n```\n> \n> Helper for reading 2-byte register `reg` from a device at address `addr`.\n> In case of success returns a numeric big-endian value: e.g. if 0x01, 0x02\n> was read from a device, 0x0102 will be returned.\n> \n> In case of error returns -1.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_i2c_read_reg_n",
    "file": "[mgos_i2c.h](https://github.com/mongoose-os-libs/i2c/blob/master/include/mgos_i2c.h)",
    "doc": "\n```c\nbool mgos_i2c_read_reg_n(struct mgos_i2c *conn, uint16_t addr, uint8_t reg,\n                         size_t n, uint8_t *buf);\n```\n> \n> Helper for reading `n`-byte register value from a device. Returns true on\n> success, false on error. Data is written to `buf`, which should be large\n> enough.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_i2c_write_reg_b",
    "file": "[mgos_i2c.h](https://github.com/mongoose-os-libs/i2c/blob/master/include/mgos_i2c.h)",
    "doc": "\n```c\nbool mgos_i2c_write_reg_b(struct mgos_i2c *conn, uint16_t addr, uint8_t reg,\n                          uint8_t value);\n```\n> \n> Helper for writing 1-byte register `reg` to a device at address `addr`.\n> Returns `true` in case of success, `false` otherwise.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_i2c_write_reg_w",
    "file": "[mgos_i2c.h](https://github.com/mongoose-os-libs/i2c/blob/master/include/mgos_i2c.h)",
    "doc": "\n```c\nbool mgos_i2c_write_reg_w(struct mgos_i2c *conn, uint16_t addr, uint8_t reg,\n                          uint16_t value);\n```\n> \n> Helper for writing 2-byte register `reg` to a device at address `addr`.\n> The value is big-endian: e.g. if `value` is `0x0102`, then `0x01, 0x02`\n> will be written.\n> Returns `true` in case of success, `false` otherwise.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_i2c_write_reg_n",
    "file": "[mgos_i2c.h](https://github.com/mongoose-os-libs/i2c/blob/master/include/mgos_i2c.h)",
    "doc": "\n```c\nbool mgos_i2c_write_reg_n(struct mgos_i2c *conn, uint16_t addr, uint8_t reg,\n                          size_t n, const uint8_t *buf);\n```\n> \n> Helper for writing `n`-byte register `reg` to a device at address `addr`.\n> Returns `true` in case of success, `false` otherwise.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_i2c_setbits_reg_b",
    "file": "[mgos_i2c.h](https://github.com/mongoose-os-libs/i2c/blob/master/include/mgos_i2c.h)",
    "doc": "\n```c\nbool mgos_i2c_setbits_reg_b(struct mgos_i2c *conn, uint16_t addr, uint8_t reg,\n                            uint8_t bitoffset, uint8_t bitlen, uint8_t value);\nbool mgos_i2c_getbits_reg_b(struct mgos_i2c *conn, uint16_t addr, uint8_t reg,\n                            uint8_t bitoffset, uint8_t bitlen, uint8_t *value);\nbool mgos_i2c_setbits_reg_w(struct mgos_i2c *conn, uint16_t addr, uint8_t reg,\n                            uint8_t bitoffset, uint8_t bitlen, uint16_t value);\nbool mgos_i2c_getbits_reg_w(struct mgos_i2c *conn, uint16_t addr, uint8_t reg,\n                            uint8_t bitoffset, uint8_t bitlen, uint16_t *value);\n```\n> \n> Helper to set/get a number of bits in a register `reg` on a device at\n> address `addr`.\n> - bitoffset: 0..n, is the position at which to write `value`\n>              n=7 for reg_b, n=15 for reg_w\n> - bitlen   : 1..m, number of bits to write\n>              m=8 for reg_b, m=16 for reg_w\n> - value    : the value to write there\n> \n> Invariants:\n> - value must fit in `bitlen` (ie value < 2^bitlen)\n> - bitlen+bitoffset <= register size (8 for reg_b, 16 for reg_w)\n> - bitlen cannot be 0.\n> - *conn cannot be NULL.\n> \n> The `setbits` call will write the bits to the register, the `getbits` call\n> will return the value of those bits in *value.\n> \n> Returns `true` in case of success, `false` otherwise.\n> \n> Examples (the bits set or get are between []):\n> 1) If register was 0x00 (0b00000000)\n>    mgos_i2c_setbits_reg_b(conn, addr, reg, 0, 1, 1);\n>    Register will be 0x01 (0b0000000[1])\n> 2) If register was 0xffff (0b1111111111111111)\n>    mgos_i2c_setbits_reg_w(conn, addr, reg, 14, 2, 0);\n>    Register will be 0x3fff (0b[00]11111111111111)\n> 3) If register was 0xabcd (0b1010101111001101)\n>    mgos_i2c_setbits_reg_w(conn, addr, reg, 10, 4, 5);\n>    Register will be 0x97cd (0b10[0101]1111001101)\n> 4) If register was 0xabcd (0b1010101111001101)\n>    mgos_i2c_getbits_reg_w(conn, addr, reg, 0, 2, &value);\n>    value will be 1   (0b10101011110011[01])\n>    mgos_i2c_getbits_reg_w(conn, addr, reg, 13, 3, &value);\n>    value will be 5   (0b[101]0101111001101)\n>    mgos_i2c_getbits_reg_w(conn, addr, reg, 6, 5, &value);\n>    value will be 15  (0b10101[01111]001101)\n>    mgos_i2c_getbits_reg_w(conn, addr, reg, 5, 9, &value);\n>    value will be 350 (0b10[101011110]01101)\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_i2c_close",
    "file": "[mgos_i2c.h](https://github.com/mongoose-os-libs/i2c/blob/master/include/mgos_i2c.h)",
    "doc": "\n```c\nvoid mgos_i2c_close(struct mgos_i2c *conn);\n```\n>  Close i2c connection and free resources. \n",
    "lang": "c"
  },
  {
    "name": "mgos_i2c_get_bus",
    "file": "[mgos_i2c.h](https://github.com/mongoose-os-libs/i2c/blob/master/include/mgos_i2c.h)",
    "doc": "\n```c\nstruct mgos_i2c *mgos_i2c_get_bus(int bus_no);\n```\n>  Return bus object for the specified bus number. \n",
    "lang": "c"
  },
  {
    "name": "mgos_i2c_get_global",
    "file": "[mgos_i2c.h](https://github.com/mongoose-os-libs/i2c/blob/master/include/mgos_i2c.h)",
    "doc": "\n```c\nstruct mgos_i2c *mgos_i2c_get_global(void);\n```\n>  Return the default I2C bus. Equivalent to `mgos_i2c_get_bus(0)`. \n",
    "lang": "c"
  },
  {
    "name": "mgos_i2c_reset_bus",
    "file": "[mgos_i2c.h](https://github.com/mongoose-os-libs/i2c/blob/master/include/mgos_i2c.h)",
    "doc": "\n```c\nbool mgos_i2c_reset_bus(int sda_gpio, int scl_gpio);\n```\n>  Init given pins as OD outputs and perform bus reset\n> by sending dummy clocks. \n",
    "lang": "c"
  },
  {
    "name": "I2C.get()",
    "file": "[api_i2c.js](https://github.com/mongoose-os-libs/i2c/blob/master/mjs_fs/api_i2c.js)",
    "doc": "\n```javascript\nI2C.get()\n```\nGet I2C bus handle. Return value: opaque pointer.\n",
    "lang": "js"
  },
  {
    "name": "I2C.close(handle)",
    "file": "[api_i2c.js](https://github.com/mongoose-os-libs/i2c/blob/master/mjs_fs/api_i2c.js)",
    "doc": "\n```javascript\nI2C.close(handle)\n```\nClose I2C handle. Return value: none.\n",
    "lang": "js"
  },
  {
    "name": "I2C.write(handle, addr, buf, size, stop)",
    "file": "[api_i2c.js](https://github.com/mongoose-os-libs/i2c/blob/master/mjs_fs/api_i2c.js)",
    "doc": "\n```javascript\nI2C.write(handle, addr, buf, size, stop)\n```\nSend a byte array to I2C.\nIf stop is true, the bus will be released at the end.\nReturn value: success, true/false.\n",
    "lang": "js"
  },
  {
    "name": "I2C.read(handle, addr, len, stop)",
    "file": "[api_i2c.js](https://github.com/mongoose-os-libs/i2c/blob/master/mjs_fs/api_i2c.js)",
    "doc": "\n```javascript\nI2C.read(handle, addr, len, stop)\n```\nRead specified number of bytes from the specified address.\nIf stop is true, the bus will be released at the end.\nReturn value: null on error, string with data on success. Example:\n```javascript\nlet data = I2C.read(bus, 31, 3, true);  // Read 3 bytes\nif (data) print(JSON.stringify([data.at(0), data.at(1), data.at(2)]));\n```\n",
    "lang": "js"
  },
  {
    "name": "I2C.stop(handle)",
    "file": "[api_i2c.js](https://github.com/mongoose-os-libs/i2c/blob/master/mjs_fs/api_i2c.js)",
    "doc": "\n```javascript\nI2C.stop(handle)\n```\nSet i2c Stop condition. Releases the bus.\nReturn value: none.\n",
    "lang": "js"
  },
  {
    "name": "I2C.readRegB(handle, addr, reg)",
    "file": "[api_i2c.js](https://github.com/mongoose-os-libs/i2c/blob/master/mjs_fs/api_i2c.js)",
    "doc": "\n```javascript\nI2C.readRegB(handle, addr, reg)\n```\nRead 1-byte register `reg` from the device at address `addr`; in case of\nsuccess return a numeric byte value from 0x00 to 0xff; otherwise return\n-1. Example:\n```javascript\n// Read 1 byte from the register 0x40 of the device at the address 0x12\nlet val = I2C.readRegB(bus, 0x12, 0x40);\nif (val >= 0) print(val);\n```\n",
    "lang": "js"
  },
  {
    "name": "I2C.readRegW(handle, addr, reg)",
    "file": "[api_i2c.js](https://github.com/mongoose-os-libs/i2c/blob/master/mjs_fs/api_i2c.js)",
    "doc": "\n```javascript\nI2C.readRegW(handle, addr, reg)\n```\nRead 2-byte register `reg` from the device at address `addr`; in case of\nsuccess return a numeric value; e.g. if 0x01, 0x02 was read from a device,\n0x0102 will be returned. In case of a failure return -1.\n```javascript\n// Read 2 bytes from the register 0x40 of the device at the address 0x12\nlet val = I2C.readRegW(bus, 0x12, 0x40);\nif (val >= 0) print(val);\n```\n",
    "lang": "js"
  },
  {
    "name": "I2C.readRegN(handle, addr, reg, num)",
    "file": "[api_i2c.js](https://github.com/mongoose-os-libs/i2c/blob/master/mjs_fs/api_i2c.js)",
    "doc": "\n```javascript\nI2C.readRegN(handle, addr, reg, num)\n```\nRead N-byte register `reg` from the device at address `addr`. In case of\nsuccess return a string with data; otherwise return an empty string.\n\nE.g. if 0x61, 0x62, 0x63 was read from a device, \"abc\" will be returned.\nYou can get numeric values using `at(n)`, e.g. `\"abc\".at(0)` is `0x61`.\n\n```javascript\n// Read 7 bytes from the register 0x40 of the device at the address 0x12\nlet buf = I2C.readRegN(bus, 0x12, 0x40, 7);\nif (buf != \"\") for (let i = 0; i < buf.length; i++) { print(buf.at(i)); }\n```\n",
    "lang": "js"
  },
  {
    "name": "I2C.writeRegB(handle, addr, reg, val)",
    "file": "[api_i2c.js](https://github.com/mongoose-os-libs/i2c/blob/master/mjs_fs/api_i2c.js)",
    "doc": "\n```javascript\nI2C.writeRegB(handle, addr, reg, val)\n```\nWrite numeric `val` (from 0x00 to 0xff) into 1-byte register `reg` at\naddress `addr`.  Return `true` on success, `false` on failure.\n```javascript\n// Write a byte 0x55 to the register 0x40 of the device at the address 0x12\nlet result = I2C.writeRegB(bus, 0x12, 0x40, 0x55);\nif (result) print('success') else print('failure');\n```\n",
    "lang": "js"
  },
  {
    "name": "I2C.writeRegW(handle, addr, reg, val)",
    "file": "[api_i2c.js](https://github.com/mongoose-os-libs/i2c/blob/master/mjs_fs/api_i2c.js)",
    "doc": "\n```javascript\nI2C.writeRegW(handle, addr, reg, val)\n```\nWrite numeric `val` into 2-byte register `reg` at address `addr`. E.g.\nif `val` is `0x0102`, then `0x01, 0x02` will be written.\nReturn `true` on success, `false` on failure.\n```javascript\n// Write a [0x55, 0x66] to the register 0x40 of the device at the address 0x12\nlet result = I2C.writeRegW(bus, 0x12, 0x40, 0x5566);\nif (result) print('success') else print('failure');\n```\n",
    "lang": "js"
  },
  {
    "name": "I2C.writeRegN(handle, addr, reg, n, buf)",
    "file": "[api_i2c.js](https://github.com/mongoose-os-libs/i2c/blob/master/mjs_fs/api_i2c.js)",
    "doc": "\n```javascript\nI2C.writeRegN(handle, addr, reg, n, buf)\n```\nWrite n first bytes of the string `buf` into the  register `reg` at\naddress `addr`. E.g.  if `buf` is `\"abc\"`, then `0x61, 0x62, 0x63` will be\nwritten.\nReturn `true` on success, `false` on failure.\n```javascript\n// Write a [0x55, 0x66, 0x77] to the register 0x40 of the device at the address 0x12\nlet result = I2C.writeRegN(bus, 0x12, 0x40, 3, \"\\x55\\x66\\x77\");\nif (result) print('success') else print('failure');\n```\n",
    "lang": "js"
  },
  {
    "name": "swap",
    "file": "[mgos_ili9341.h](https://github.com/mongoose-os-libs/ili9341-spi/blob/master/include/mgos_ili9341.h)",
    "doc": "\n```c\n#define swap(a, b)    { int16_t t = a; a = b; b = t; }\n```\n> LCD Horizontal Refresh Right-Left\n",
    "lang": "c"
  },
  {
    "name": "set_odr",
    "file": "[mgos_imu.h](https://github.com/mongoose-os-libs/imu/blob/master/include/mgos_imu.h)",
    "doc": "\n```c\nfloat                   odr;    // Data rate, in Hz. See doc for set_odr().\n  float                   scale;  // Scale. See doc for set_scale().\n  bool                    no_rst; // Do not perform reset of the device when configuring.\n};\n```\n> Gyroscope type.\n",
    "lang": "c"
  },
  {
    "name": "set_odr",
    "file": "[mgos_imu.h](https://github.com/mongoose-os-libs/imu/blob/master/include/mgos_imu.h)",
    "doc": "\n```c\nfloat                  odr;    // Data rate, in Hz. See doc for set_odr().\n  float                  scale;  // Scale. See doc for set_scale().\n  bool                   no_rst; // Do not perform reset of the device when configuring.\n};\n```\n> Accelerometer type.\n",
    "lang": "c"
  },
  {
    "name": "set_odr",
    "file": "[mgos_imu.h](https://github.com/mongoose-os-libs/imu/blob/master/include/mgos_imu.h)",
    "doc": "\n```c\nfloat                  odr;    // Data rate, in Hz. See doc for set_odr().\n  float                  scale;  // Scale. See doc for set_scale().\n  bool                   no_rst; // Do not perform reset of the device when configuring.\n};\n```\n> Magnetometer type.\n",
    "lang": "c"
  },
  {
    "name": "mgos_ina219_create",
    "file": "[mgos_ina219.h](https://github.com/mongoose-os-libs/ina219-i2c/blob/master/include/mgos_ina219.h)",
    "doc": "\n```c\nstruct mgos_ina219 *mgos_ina219_create(struct mgos_i2c *i2c, uint8_t i2caddr);\n```\n> \n> Initialize a INA219 on the I2C bus `i2c` at address specified in `i2caddr`\n> parameter (default INA219 is on address 0x40). The sensor will be polled for\n> validity, upon success a new `struct mgos_ina219` is allocated and\n> returned. If the device could not be found, NULL is returned.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_ina219_destroy",
    "file": "[mgos_ina219.h](https://github.com/mongoose-os-libs/ina219-i2c/blob/master/include/mgos_ina219.h)",
    "doc": "\n```c\nvoid mgos_ina219_destroy(struct mgos_ina219 **sensor);\n```\n> \n> Destroy the data structure associated with a INA219 device. The reference\n> to the pointer of the `struct mgos_ina219` has to be provided, and upon\n> successful destruction, its associated memory will be freed and the pointer\n> set to NULL.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_ina219_get_bus_voltage",
    "file": "[mgos_ina219.h](https://github.com/mongoose-os-libs/ina219-i2c/blob/master/include/mgos_ina219.h)",
    "doc": "\n```c\nbool mgos_ina219_get_bus_voltage(struct mgos_ina219 *sensor, float *volts);\n```\n>  Measure the bus voltage on the device. Return the measured voltage in `*volts`,\n> in units of Volts.\n> Returns true on success and false on failure, in which case `*volts` is unspecified.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_ina219_get_shunt_voltage",
    "file": "[mgos_ina219.h](https://github.com/mongoose-os-libs/ina219-i2c/blob/master/include/mgos_ina219.h)",
    "doc": "\n```c\nbool mgos_ina219_get_shunt_voltage(struct mgos_ina219 *sensor, float *volts);\n```\n>  Measure the shunt voltage on the device. Return the measured voltage in `*volts`,\n> in units of Volts.\n> Returns true on success and false on failure, in which case `*volts` is unspecified.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_ina219_set_shunt_resistance",
    "file": "[mgos_ina219.h](https://github.com/mongoose-os-libs/ina219-i2c/blob/master/include/mgos_ina219.h)",
    "doc": "\n```c\nbool mgos_ina219_set_shunt_resistance(struct mgos_ina219 *sensor, float ohms);\n```\n>  Set the shunt resistor value in units of Ohms.\n> Typical values is ohms=0.100 (which yields a 3.2A range on the current sensor).\n> Returns true on success and false on failure.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_ina219_get_shunt_resistance",
    "file": "[mgos_ina219.h](https://github.com/mongoose-os-libs/ina219-i2c/blob/master/include/mgos_ina219.h)",
    "doc": "\n```c\nbool mgos_ina219_get_shunt_resistance(struct mgos_ina219 *sensor, float *ohms);\n```\n>  Get the shunt resistor value in units of Ohms.\n> Returns true on success and false on failure, in which case `*ohms` is unspecified.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_ina226_create",
    "file": "[mgos_ina226.h](https://github.com/mongoose-os-libs/ina226-i2c/blob/master/include/mgos_ina226.h)",
    "doc": "\n```c\nstruct mgos_ina226 *mgos_ina226_create(struct mgos_i2c *i2c, uint8_t i2caddr);\n```\n> \n> Initialize a INA226 on the I2C bus `i2c` at address specified in `i2caddr`\n> parameter (default INA226 is on address 0x40). The sensor will be polled for\n> validity, upon success a new `struct mgos_ina226` is allocated and\n> returned. If the device could not be found, NULL is returned.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_ina226_destroy",
    "file": "[mgos_ina226.h](https://github.com/mongoose-os-libs/ina226-i2c/blob/master/include/mgos_ina226.h)",
    "doc": "\n```c\nvoid mgos_ina226_destroy(struct mgos_ina226 **sensor);\n```\n> \n> Destroy the data structure associated with a INA226 device. The reference\n> to the pointer of the `struct mgos_ina226` has to be provided, and upon\n> successful destruction, its associated memory will be freed and the pointer\n> set to NULL.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_ina226_get_bus_voltage",
    "file": "[mgos_ina226.h](https://github.com/mongoose-os-libs/ina226-i2c/blob/master/include/mgos_ina226.h)",
    "doc": "\n```c\nbool mgos_ina226_get_bus_voltage(struct mgos_ina226 *sensor, float *volts);\n```\n>  Measure the bus voltage on the device. Return the measured voltage in `*volts`,\n> in units of Volts.\n> Returns true on success and false on failure, in which case `*volts` is unspecified.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_ina226_get_shunt_voltage",
    "file": "[mgos_ina226.h](https://github.com/mongoose-os-libs/ina226-i2c/blob/master/include/mgos_ina226.h)",
    "doc": "\n```c\nbool mgos_ina226_get_shunt_voltage(struct mgos_ina226 *sensor, float *volts);\n```\n>  Measure the shunt voltage on the device. Return the measured voltage in `*volts`,\n> in units of Volts.\n> Returns true on success and false on failure, in which case `*volts` is unspecified.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_ina226_set_shunt_resistance",
    "file": "[mgos_ina226.h](https://github.com/mongoose-os-libs/ina226-i2c/blob/master/include/mgos_ina226.h)",
    "doc": "\n```c\nbool mgos_ina226_set_shunt_resistance(struct mgos_ina226 *sensor, float ohms);\n```\n>  Set the shunt resistor value in units of Ohms.\n> Typical values is ohms=0.100 (which yields a 3.2A range on the current sensor).\n> Returns true on success and false on failure.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_ina226_get_shunt_resistance",
    "file": "[mgos_ina226.h](https://github.com/mongoose-os-libs/ina226-i2c/blob/master/include/mgos_ina226.h)",
    "doc": "\n```c\nbool mgos_ina226_get_shunt_resistance(struct mgos_ina226 *sensor, float *ohms);\n```\n>  Get the shunt resistor value in units of Ohms.\n> Returns true on success and false on failure, in which case `*ohms` is unspecified.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_ina3221_create",
    "file": "[mgos_ina3221.h](https://github.com/mongoose-os-libs/ina3221-i2c/blob/master/include/mgos_ina3221.h)",
    "doc": "\n```c\nstruct mgos_ina3221 *mgos_ina3221_create(struct mgos_i2c *i2c, uint8_t i2caddr);\n```\n> \n> Initialize a INA3221 on the I2C bus `i2c` at address specified in `i2caddr`\n> parameter (default INA3221 is on address 0x40). The sensor will be polled for\n> validity, upon success a new `struct mgos_ina3221` is allocated and\n> returned. If the device could not be found, NULL is returned.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_ina3221_destroy",
    "file": "[mgos_ina3221.h](https://github.com/mongoose-os-libs/ina3221-i2c/blob/master/include/mgos_ina3221.h)",
    "doc": "\n```c\nvoid mgos_ina3221_destroy(struct mgos_ina3221 **sensor);\n```\n> \n> Destroy the data structure associated with a INA3221 device. The reference\n> to the pointer of the `struct mgos_ina3221` has to be provided, and upon\n> successful destruction, its associated memory will be freed and the pointer\n> set to NULL.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_ina3221_get_bus_voltage",
    "file": "[mgos_ina3221.h](https://github.com/mongoose-os-libs/ina3221-i2c/blob/master/include/mgos_ina3221.h)",
    "doc": "\n```c\nbool mgos_ina3221_get_bus_voltage(struct mgos_ina3221 *sensor, uint8_t chan, float *volts);\n```\n>  Measure the bus voltage on channel `chan` (which can be 1, 2, or 3). Return the\n> measured voltage in `*volts`, in units of Volts.\n> Returns true on success and false on failure, in which case `*volts` is unspecified.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_ina3221_get_shunt_voltage",
    "file": "[mgos_ina3221.h](https://github.com/mongoose-os-libs/ina3221-i2c/blob/master/include/mgos_ina3221.h)",
    "doc": "\n```c\nbool mgos_ina3221_get_shunt_voltage(struct mgos_ina3221 *sensor, uint8_t chan, float *volts);\n```\n>  Measure the shunt voltage on channel `chan` (which can be 1, 2, or 3). Return the\n> measured voltage in `*volts`, in units of Volts.\n> Returns true on success and false on failure, in which case `*volts` is unspecified.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_ina3221_set_shunt_resistance",
    "file": "[mgos_ina3221.h](https://github.com/mongoose-os-libs/ina3221-i2c/blob/master/include/mgos_ina3221.h)",
    "doc": "\n```c\nbool mgos_ina3221_set_shunt_resistance(struct mgos_ina3221 *sensor, uint8_t chan, float ohms);\n```\n>  Set the shunt resistor value in units of Ohms on channel `chan` (which can be 1, 2 or 3).\n> Typical values is ohms=0.100 (which yields a 1.6A range on the current sensor).\n> Returns true on success and false on failure.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_ina3221_get_shunt_resistance",
    "file": "[mgos_ina3221.h](https://github.com/mongoose-os-libs/ina3221-i2c/blob/master/include/mgos_ina3221.h)",
    "doc": "\n```c\nbool mgos_ina3221_get_shunt_resistance(struct mgos_ina3221 *sensor, uint8_t chan, float *ohms);\n```\n>  Get the shunt resistor value in units of Ohms on channel `chan` (which can be 1, 2 or 3).\n> Returns true on success and false on failure, in which case `*ohms` is unspecified.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_irrecv_nec_create",
    "file": "[mgos_ir.h](https://github.com/mongoose-os-libs/ir/blob/master/include/mgos_ir.h)",
    "doc": "\n```c\nstruct mgos_irrecv_nec_s *mgos_irrecv_nec_create(\n  int pin,\n  void (*cb)(int, void *),\n  void *userdata\n);\n```\n> \n> Create an object instance of IR receiver for NEC protocol.\n> Return value: an object with the methods described below.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_irrecv_nec_close",
    "file": "[mgos_ir.h](https://github.com/mongoose-os-libs/ir/blob/master/include/mgos_ir.h)",
    "doc": "\n```c\nvoid mgos_irrecv_nec_close(struct mgos_irrecv_nec_s *obj);\n```\n> \n> Destroy an object instance of IR receiver for NEC protocol.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_irsend_nec",
    "file": "[mgos_ir.h](https://github.com/mongoose-os-libs/ir/blob/master/include/mgos_ir.h)",
    "doc": "\n```c\nvoid mgos_irsend_nec(int pin, int code, bool tsop);\n```\n> \n> Send IR code for NEC protocol.\n> Params:\n> pin:  GPIO number.\n> code: 32-bit code.\n> tsop: mode: true - mimic TSOP signal, false - drive real IR led at 38 kHz.\n>  \n",
    "lang": "c"
  },
  {
    "name": "IR.Receiver.NEC.create(pin, callback, userdata)",
    "file": "[api_ir.js](https://github.com/mongoose-os-libs/ir/blob/master/mjs_fs/api_ir.js)",
    "doc": "\n```javascript\nIR.Receiver.NEC.create(pin, callback, userdata)\n```\nCreate an object instance of IR receiver for NEC protocol.\nReturn value: an object with the methods described below.\n",
    "lang": "js"
  },
  {
    "name": "myIR.close()",
    "file": "[api_ir.js](https://github.com/mongoose-os-libs/ir/blob/master/mjs_fs/api_ir.js)",
    "doc": "\n```javascript\nmyIR.close()\n```\nClose receiver handle. Return value: none.\n",
    "lang": "js"
  },
  {
    "name": "IR.Sender.NEC.pwm(pin, code)",
    "file": "[api_ir.js](https://github.com/mongoose-os-libs/ir/blob/master/mjs_fs/api_ir.js)",
    "doc": "\n```javascript\nIR.Sender.NEC.pwm(pin, code)\n```\nSend NEC IR code via real IR led. Return value: none.\n",
    "lang": "js"
  },
  {
    "name": "IR.Sender.NEC.tsop(pin, code)",
    "file": "[api_ir.js](https://github.com/mongoose-os-libs/ir/blob/master/mjs_fs/api_ir.js)",
    "doc": "\n```javascript\nIR.Sender.NEC.tsop(pin, code)\n```\nMimic TSOP receiver: drive a pin as if it would be connected to a TSOP receiver. Return value: none.\n",
    "lang": "js"
  },
  {
    "name": "MGOS_JSTORE_REF_BY_ID",
    "file": "[mgos_jstore.h](https://github.com/mongoose-os-libs/jstore/blob/master/include/mgos_jstore.h)",
    "doc": "\n```c\n#define MGOS_JSTORE_REF_BY_ID(x)                               \\\n  ((struct mgos_jstore_ref){                                   \\\n      .type = MGOS_JSTORE_REF_TYPE_BY_ID, .data = {.id = (x)}, \\\n  })\n```\n> \n> Constructs reference to an item by the given struct mg_str id.\n>  \n",
    "lang": "c"
  },
  {
    "name": "MGOS_JSTORE_REF_BY_INDEX",
    "file": "[mgos_jstore.h](https://github.com/mongoose-os-libs/jstore/blob/master/include/mgos_jstore.h)",
    "doc": "\n```c\n#define MGOS_JSTORE_REF_BY_INDEX(x)                                  \\\n  ((struct mgos_jstore_ref){                                         \\\n      .type = MGOS_JSTORE_REF_TYPE_BY_INDEX, .data = {.index = (x)}, \\\n  })\n```\n> \n> Constructs reference to an item by the given int index.\n>  \n",
    "lang": "c"
  },
  {
    "name": "MGOS_JSTORE_REF_BY_HND",
    "file": "[mgos_jstore.h](https://github.com/mongoose-os-libs/jstore/blob/master/include/mgos_jstore.h)",
    "doc": "\n```c\n#define MGOS_JSTORE_REF_BY_HND(x)                                \\\n  ((struct mgos_jstore_ref){                                     \\\n      .type = MGOS_JSTORE_REF_TYPE_BY_HND, .data = {.hnd = (x)}, \\\n  })\n```\n> \n> Constructs reference to an item by the given opaque handler\n> mgos_jstore_item_hnd_t hnd.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_jstore_create",
    "file": "[mgos_jstore.h](https://github.com/mongoose-os-libs/jstore/blob/master/include/mgos_jstore.h)",
    "doc": "\n```c\nstruct mgos_jstore *mgos_jstore_create(const char *json_path, char **perr);\n```\n> \n> Create jstore from the JSON file `json_path`. If file does not exist or\n> is empty, it's not an error and will just result in an empty jstore.\n> \n> If `perr` is not NULL, the error message will be written there (or NULL\n> in case of success). The caller should free the error message.\n>  \n",
    "lang": "c"
  },
  {
    "name": "(*mgos_jstore_cb)",
    "file": "[mgos_jstore.h](https://github.com/mongoose-os-libs/jstore/blob/master/include/mgos_jstore.h)",
    "doc": "\n```c\ntypedef bool (*mgos_jstore_cb)(struct mgos_jstore *store, int idx,\n                               mgos_jstore_item_hnd_t hnd,\n                               const struct mg_str *id,\n                               const struct mg_str *data, void *userdata);\n```\n> \n> Callback for `mgos_jstore_iterate`, called for each item in the jstore.\n> `idx` is a zero-based index of the item, `hnd` is an opaque item's\n> handle, can be used for editing or removing it without having to look for\n> the item by the id.\n> \n> The callback should return true to continue iteration, or false to stop.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_jstore_iterate",
    "file": "[mgos_jstore.h](https://github.com/mongoose-os-libs/jstore/blob/master/include/mgos_jstore.h)",
    "doc": "\n```c\nbool mgos_jstore_iterate(struct mgos_jstore *store, mgos_jstore_cb cb,\n                         void *userdata);\n```\n> \n> Call provided callback for each item in the store; see `mgos_jstore_cb` for\n> details.\n> \n> Returns false if the callback has returned false at least once. Returns true\n> if callback never returned false.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_jstore_item_add",
    "file": "[mgos_jstore.h](https://github.com/mongoose-os-libs/jstore/blob/master/include/mgos_jstore.h)",
    "doc": "\n```c\nstruct mg_str mgos_jstore_item_add(struct mgos_jstore *store, struct mg_str id,\n                                   struct mg_str data,\n                                   enum mgos_jstore_ownership id_own,\n                                   enum mgos_jstore_ownership data_own,\n                                   mgos_jstore_item_hnd_t *phnd, int *pindex,\n                                   char **perr);\n```\n> \n> Add a new item to the store. If `id` contains some data (`id.p` is not NULL),\n> the provided id will be used; otherwise, the id will be randomly generated.\n> In any case, the actual id is returned; the caller should NOT free it,\n> and it remains valid until the store item is freed.\n> \n> Data should be a valid JSON string. Examples of valid data:\n> \n> - Array: `\"[\\\"foo\", \"bar\\\"]\"`\n> - String: `\"\\\"foo bar\\\"\"` (with explicit quotes)\n> \n> Plain `\"foo bar\"` would be an invalid data.\n> \n> Ownership of `id` and `data` is determined by `id_own` and `data_own`,\n> see `enum mgos_jstore_ownership`.\n> \n> If `phnd` is not NULL, the new item's handle is written there.\n> If `pindex` is not NULL, the new item's index is written there.\n> \n> Returns the id of a new item. In case of an error, that id will be empty.\n> \n> If `perr` is not NULL, the error message will be written there (or NULL\n> in case of success). The caller should free the error message.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_jstore_item_edit",
    "file": "[mgos_jstore.h](https://github.com/mongoose-os-libs/jstore/blob/master/include/mgos_jstore.h)",
    "doc": "\n```c\nbool mgos_jstore_item_edit(struct mgos_jstore *store,\n                           const struct mgos_jstore_ref ref, struct mg_str data,\n                           enum mgos_jstore_ownership data_own, char **perr);\n```\n> \n> Edit item by the reference (see `MGOS_JSTORE_REF_BY_...()` macros above)\n> \n> Returns true in case of success, false otherwise.\n> \n> If `perr` is not NULL, the error message will be written there (or NULL\n> in case of success). The caller should free the error message.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_jstore_item_remove",
    "file": "[mgos_jstore.h](https://github.com/mongoose-os-libs/jstore/blob/master/include/mgos_jstore.h)",
    "doc": "\n```c\nbool mgos_jstore_item_remove(struct mgos_jstore *store,\n                             const struct mgos_jstore_ref ref, char **perr);\n```\n> \n> Remove item by the reference (see `MGOS_JSTORE_REF_BY_...()` macros above)\n> \n> Returns true in case of success, false otherwise.\n> \n> If `perr` is not NULL, the error message will be written there (or NULL\n> in case of success). The caller should free the error message.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_jstore_item_get",
    "file": "[mgos_jstore.h](https://github.com/mongoose-os-libs/jstore/blob/master/include/mgos_jstore.h)",
    "doc": "\n```c\nbool mgos_jstore_item_get(struct mgos_jstore *store,\n                          const struct mgos_jstore_ref ref, struct mg_str *id,\n                          struct mg_str *data, mgos_jstore_item_hnd_t *phnd,\n                          int *pindex, char **perr);\n```\n> \n> Get item details by the given reference (see `MGOS_JSTORE_REF_BY_...()`\n> macros above). All output pointers (`id`, `data`, `phnd`, `pindex`) are\n> allowed to be NULL.\n> \n> Returns true in case of success, false otherwise.\n> \n> If `perr` is not NULL, the error message will be written there (or NULL\n> in case of success). The caller should free the error message.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_jstore_save",
    "file": "[mgos_jstore.h](https://github.com/mongoose-os-libs/jstore/blob/master/include/mgos_jstore.h)",
    "doc": "\n```c\nbool mgos_jstore_save(struct mgos_jstore *store, const char *json_path,\n                      char **perr);\n```\n> \n> Save jstore to the JSON file `json_path`.\n> \n> Returns true in case of success, false otherwise.\n> \n> If `perr` is not NULL, the error message will be written there (or NULL\n> in case of success). The caller should free the error message.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_jstore_items_cnt",
    "file": "[mgos_jstore.h](https://github.com/mongoose-os-libs/jstore/blob/master/include/mgos_jstore.h)",
    "doc": "\n```c\nint mgos_jstore_items_cnt(struct mgos_jstore *store);\n```\n> \n> Get number of items in a jstore.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_jstore_free",
    "file": "[mgos_jstore.h](https://github.com/mongoose-os-libs/jstore/blob/master/include/mgos_jstore.h)",
    "doc": "\n```c\nvoid mgos_jstore_free(struct mgos_jstore *store);\n```\n> \n> Free memory occupied by jstore and all its items.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_location_get",
    "file": "[mgos_location.h](https://github.com/mongoose-os-libs/location/blob/master/include/mgos_location.h)",
    "doc": "\n```c\nbool mgos_location_get(struct mgos_location_lat_lon *loc);\n```\n> \n> Fills provided `loc` with the device location data (currently device just\n> uses values from the config), see `struct mgos_location_lat_lon`. Returns\n> `true` on success, `false` otherwise.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_max7219_create",
    "file": "[mgos_max7219.h](https://github.com/mongoose-os-libs/max7219-spi/blob/master/include/mgos_max7219.h)",
    "doc": "\n```c\nstruct mgos_max7219 *mgos_max7219_create(struct mgos_spi *spi, uint8_t cs_index);\n```\n> \n> Initialize a MAX7219 on the SPI bus `spi` using the chipselect specified in\n> `cs_index` parameter (see `spi.cs*_gpio`). Upon success a new\n> `struct mgos_max7219` is  allocated and returned.\n> If the device could not be found or initialized, NULL is returned.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_max7219_destroy",
    "file": "[mgos_max7219.h](https://github.com/mongoose-os-libs/max7219-spi/blob/master/include/mgos_max7219.h)",
    "doc": "\n```c\nbool mgos_max7219_destroy(struct mgos_max7219 **dev);\n```\n> \n> Destroy the data structure associated with a MAX7219 device. The reference\n> to the pointer of the `struct mgos_max7219` has to be provided, and upon\n> successful destruction, its associated memory will be freed and the pointer\n> set to NULL and true will be returned.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_max7219_set_num_devices",
    "file": "[mgos_max7219.h](https://github.com/mongoose-os-libs/max7219-spi/blob/master/include/mgos_max7219.h)",
    "doc": "\n```c\nbool mgos_max7219_set_num_devices(struct mgos_max7219 *dev, uint8_t num_devices);\n```\n> \n> Set the number of devices in the daisychain (1 or more).\n> Returns true on success or false on failure.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_max7219_set_intensity",
    "file": "[mgos_max7219.h](https://github.com/mongoose-os-libs/max7219-spi/blob/master/include/mgos_max7219.h)",
    "doc": "\n```c\nbool mgos_max7219_set_intensity(struct mgos_max7219 *dev, uint8_t intensity);\n```\n> \n> Set display intensity (brightness) as a value from 0..15.\n> Returns true on success or false on failure.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_max7219_set_mode",
    "file": "[mgos_max7219.h](https://github.com/mongoose-os-libs/max7219-spi/blob/master/include/mgos_max7219.h)",
    "doc": "\n```c\nbool mgos_max7219_set_mode(struct mgos_max7219 *dev, bool codeB_enabled);\n```\n>  Set display mode, either 'raw' or 'digit':\n> - codeB_enabled: set 'false' for 'raw', or 'true' to enable 7-segment digits.\n> Returns true on success or false on failure.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_max7219_write_raw",
    "file": "[mgos_max7219.h](https://github.com/mongoose-os-libs/max7219-spi/blob/master/include/mgos_max7219.h)",
    "doc": "\n```c\nbool mgos_max7219_write_raw(struct mgos_max7219 *dev, uint8_t deviceno, uint8_t digit, uint8_t value);\n```\n> \n> Set display digit at position `digit` with a `value`\n> - deviceno: device to adddress, between 0 and num_devices-1;\n> - digit: must be between [0, 7]\n> - value: can be between [0, 255]\n> Returns true on success or false on failure.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_max7219_write_digit",
    "file": "[mgos_max7219.h](https://github.com/mongoose-os-libs/max7219-spi/blob/master/include/mgos_max7219.h)",
    "doc": "\n```c\nbool mgos_max7219_write_digit(struct mgos_max7219 *dev, uint8_t deviceno, uint8_t digit, uint8_t value);\n```\n> \n> Set display digit at position `digit` with an 7-segment character `value`\n> - deviceno: device to adddress, between 0 and num_devices-1;\n> - digit: must be between [0, 7]\n> - value: must be between [0, 15]:\n>          0-9 for numbers, , 10='-', 11='E', 12='H', 13='L', 14='P', 15=' '\n>          called Code B decoding.\n> Returns true on success or false on failure.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_max7219_write_line",
    "file": "[mgos_max7219.h](https://github.com/mongoose-os-libs/max7219-spi/blob/master/include/mgos_max7219.h)",
    "doc": "\n```c\nbool mgos_max7219_write_line(struct mgos_max7219 *dev, uint8_t digit, uint8_t *value);\n```\n> \n> Write a line of values at position `digit` across all connected devices.\n> - digit: must be between [0, 7]\n> - value: An array of exactly num_devices bytes.\n> \n> Note: If the device is in mode codeB, the values should be between [0, 15].\n> \n> Returns true on success or false on failure.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_mcp23008_create",
    "file": "[mgos_mcp23xxx.h](https://github.com/mongoose-os-libs/mcp23xxx/blob/master/include/mgos_mcp23xxx.h)",
    "doc": "\n```c\nstruct mgos_mcp23xxx *mgos_mcp23008_create(struct mgos_i2c *i2c, uint8_t i2caddr, int int_gpio);\nstruct mgos_mcp23xxx *mgos_mcp23017_create(struct mgos_i2c *i2c, uint8_t i2caddr, int int_gpio);\n```\n> \n> Initialize a MCP230XX on the I2C bus `i2c` at address specified in `i2caddr`\n> parameter (default MCP230XX is on address 0x20). The device will be polled for\n> validity, upon success a new `struct mgos_mcp23xxx` is allocated and\n> returned. If the device could not be found, NULL is returned.\n> To install an interrupt handler for the chip, set int_gpio to any valid GPIO\n> pin. Set it to -1 to disable interrupts.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_mcp23xxx_destroy",
    "file": "[mgos_mcp23xxx.h](https://github.com/mongoose-os-libs/mcp23xxx/blob/master/include/mgos_mcp23xxx.h)",
    "doc": "\n```c\nbool mgos_mcp23xxx_destroy(struct mgos_mcp23xxx **dev);\n```\n> \n> Destroy the data structure associated with a MCP230XX device. The reference\n> to the pointer of the `struct mgos_mcp23xxx` has to be provided, and upon\n> successful destruction, its associated memory will be freed and the pointer\n> set to NULL and true will be returned.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_mcp23xxx_print_state",
    "file": "[mgos_mcp23xxx.h](https://github.com/mongoose-os-libs/mcp23xxx/blob/master/include/mgos_mcp23xxx.h)",
    "doc": "\n```c\nbool mgos_mcp23xxx_print_state(struct mgos_mcp23xxx *dev);\n```\n>  Emit a logline with the pin and io register stat\n> Return true if the driver could read from the chip, false otherwise.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_mcp23xxx_gpio_set_mode",
    "file": "[mgos_mcp23xxx.h](https://github.com/mongoose-os-libs/mcp23xxx/blob/master/include/mgos_mcp23xxx.h)",
    "doc": "\n```c\nbool mgos_mcp23xxx_gpio_set_mode(struct mgos_mcp23xxx *dev, int pin, enum mgos_gpio_mode mode);\nbool mgos_mcp23xxx_gpio_set_pull(struct mgos_mcp23xxx *dev, int pin, enum mgos_gpio_pull_type pull);\nbool mgos_mcp23xxx_gpio_setup_output(struct mgos_mcp23xxx *dev, int pin, bool level);\nbool mgos_mcp23xxx_gpio_setup_input(struct mgos_mcp23xxx *dev, int pin, enum mgos_gpio_pull_type pull_type);\nbool mgos_mcp23xxx_gpio_read(struct mgos_mcp23xxx *dev, int pin);\nvoid mgos_mcp23xxx_gpio_write(struct mgos_mcp23xxx *dev, int pin, bool level);\nbool mgos_mcp23xxx_gpio_toggle(struct mgos_mcp23xxx *dev, int pin);\n```\n>  These follow `mgos_gpio.h` definitions. \n",
    "lang": "c"
  },
  {
    "name": "_read",
    "file": "[mgos_mcp9808.h](https://github.com/mongoose-os-libs/mcp9808-i2c/blob/master/include/mgos_mcp9808.h)",
    "doc": "\n```c\nuint32_t read;                 // calls to _read()\n  uint32_t read_success;         // successful _read()\n  uint32_t read_success_cached;  // calls to _read() which were cached\n  // Note: read_errors := read - read_success - read_success_cached\n  double   read_success_usecs;   // time spent in successful uncached _read()\n};\n```\n> value of mg_time() upon last call to _read()\n",
    "lang": "c"
  },
  {
    "name": "mgos_mcp9808_create",
    "file": "[mgos_mcp9808.h](https://github.com/mongoose-os-libs/mcp9808-i2c/blob/master/include/mgos_mcp9808.h)",
    "doc": "\n```c\nstruct mgos_mcp9808 *mgos_mcp9808_create(struct mgos_i2c *i2c, uint8_t i2caddr);\n```\n> \n> Initialize a MCP9808 on the I2C bus `i2c` at address specified in `i2caddr`\n> parameter (default MCP9808 is on address 0x18). The sensor will be polled for\n> validity, upon success a new `struct mgos_mcp9808` is allocated and\n> returned. If the device could not be found, NULL is returned.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_mcp9808_destroy",
    "file": "[mgos_mcp9808.h](https://github.com/mongoose-os-libs/mcp9808-i2c/blob/master/include/mgos_mcp9808.h)",
    "doc": "\n```c\nvoid mgos_mcp9808_destroy(struct mgos_mcp9808 **sensor);\n```\n> \n> Destroy the data structure associated with a MCP9808 device. The reference\n> to the pointer of the `struct mgos_mcp9808` has to be provided, and upon\n> successful destruction, its associated memory will be freed and the pointer\n> set to NULL.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_mcp9808_read",
    "file": "[mgos_mcp9808.h](https://github.com/mongoose-os-libs/mcp9808-i2c/blob/master/include/mgos_mcp9808.h)",
    "doc": "\n```c\nbool mgos_mcp9808_read(struct mgos_mcp9808 *sensor);\n```\n> \n> The sensor will be polled for its temperature and humidity data. If the poll\n> has occured in the last `MGOS_MCP9808_READ_DELAY` seconds, the cached data is\n> used (so as not to repeatedly poll the bus upon subsequent calls).\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_mcp9808_getTemperature",
    "file": "[mgos_mcp9808.h](https://github.com/mongoose-os-libs/mcp9808-i2c/blob/master/include/mgos_mcp9808.h)",
    "doc": "\n```c\nfloat mgos_mcp9808_getTemperature(struct mgos_mcp9808 *sensor);\n```\n> \n> The sensor will be polled for its temperature and humidity data. If the poll\n> has occured in the last `MGOS_MCP9808_READ_DELAY` seconds, the cached data is\n> used (so as not to repeatedly poll the bus upon subsequent calls).\n> \n> The return value is the temperature of the sensor in Celsius, or NAN if no\n> data was found.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_mcp9808_getStats",
    "file": "[mgos_mcp9808.h](https://github.com/mongoose-os-libs/mcp9808-i2c/blob/master/include/mgos_mcp9808.h)",
    "doc": "\n```c\nbool mgos_mcp9808_getStats(struct mgos_mcp9808 *sensor, struct mgos_mcp9808_stats *stats);\n```\n> \n> Returns the running statistics on the sensor interaction, the user provides\n> a pointer to a `struct mgos_mcp9808_stats` object, which is filled in by this\n> call.\n> \n> Upon success, true is returned. Otherwise, false is returned, in which case\n> the contents of `stats` is undetermined.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_mcp9808_enable",
    "file": "[mgos_mcp9808.h](https://github.com/mongoose-os-libs/mcp9808-i2c/blob/master/include/mgos_mcp9808.h)",
    "doc": "\n```c\nvoid mgos_mcp9808_enable(struct mgos_mcp9808 *sensor, bool enable);\n```\n> \n> The sensor will be enabled (true) or disabled and put into deep sleep (false)\n> based on the `enable` argument.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_mcp9808_i2c_init",
    "file": "[mgos_mcp9808.h](https://github.com/mongoose-os-libs/mcp9808-i2c/blob/master/include/mgos_mcp9808.h)",
    "doc": "\n```c\nbool mgos_mcp9808_i2c_init(void);\n```\n> \n> Initialization function for MGOS -- currently a noop.\n>  \n",
    "lang": "c"
  },
  {
    "name": "MD_MAX72XX",
    "file": "[MD_MAX72xx.h](https://github.com/mongoose-os-libs/md-max72xx/blob/master/include/MD_MAX72xx.h)",
    "doc": "\n```c\nMD_MAX72XX(uint8_t dataPin, uint8_t clkPin, uint8_t csPin, uint8_t numDevices=1);\n```\n> *\n> Class Constructor - arbitrary digital interface.\n> \n> Instantiate a new instance of the class. The parameters passed are used to\n> connect the software to the hardware. Multiple instances may co-exist\n> but they should not share the same hardware CS pin (SPI interface).\n> \n> \\param dataPin\t\toutput on the Arduino where data gets shifted out.\n> \\param clkPin\t\toutput for the clock signal.\n> \\param csPin\t\toutput for selecting the device.\n> \\param numDevices\tnumber of devices connected. Default is 1 if not supplied.\n>                    Memory for device buffers is dynamically allocated based\n>                    on this parameter.\n>    \n",
    "lang": "c"
  },
  {
    "name": "MD_MAX72XX",
    "file": "[MD_MAX72xx.h](https://github.com/mongoose-os-libs/md-max72xx/blob/master/include/MD_MAX72xx.h)",
    "doc": "\n```c\nMD_MAX72XX(uint8_t csPin, uint8_t numDevices=1);\n```\n> *\n> Class Constructor - SPI hardware interface.\n> \n> Instantiate a new instance of the class. The parameters passed are used to\n> connect the software to the hardware. Multiple instances may co-exist\n> but they should not share the same hardware CS pin (SPI interface).\n> The dataPin and the clockPin are defined by the Arduino hardware definition\n> (SPI MOSI and SCK signals).\n> \n> \\param csPin\t\toutput for selecting the device.\n> \\param numDevices\tnumber of devices connected. Default is 1 if not supplied.\n>                    Memory for device buffers is dynamically allocated based\n>                    on this parameter.\n>    \n",
    "lang": "c"
  },
  {
    "name": "begin",
    "file": "[MD_MAX72xx.h](https://github.com/mongoose-os-libs/md-max72xx/blob/master/include/MD_MAX72xx.h)",
    "doc": "\n```c\nvoid begin(void);\n```\n> *\n> Initialize the object.\n> \n> Initialise the object data. This needs to be called during setup() to initialise new\n> data for the class that cannot be done during the object creation.\n> \n> The LED hardware is initialized to the middle intensity value, all rows showing,\n> and all LEDs cleared (off). Test, shutdown and decode modes are off. Display updates\n> are on and wraparound is off.\n>    \n",
    "lang": "c"
  },
  {
    "name": "~MD_MAX72XX",
    "file": "[MD_MAX72xx.h](https://github.com/mongoose-os-libs/md-max72xx/blob/master/include/MD_MAX72xx.h)",
    "doc": "\n```c\n~MD_MAX72XX();\n```\n> *\n> Class Destructor.\n> \n> Released allocated memory and does the necessary to clean up once the object is\n> no longer required.\n>    \n",
    "lang": "c"
  },
  {
    "name": "control",
    "file": "[MD_MAX72xx.h](https://github.com/mongoose-os-libs/md-max72xx/blob/master/include/MD_MAX72xx.h)",
    "doc": "\n```c\nbool control(uint8_t dev, controlRequest_t mode, int value);\n```\n> *\n> Set the control status of the specified parameter for the specified device.\n> \n> The device has a number of control parameters that can be set through this method.\n> The type of control action required is passed through the mode parameter and\n> should be one of the control actions defined by controlRequest_t. The value that\n> needs to be supplied on the control action required is one of the defined\n> actions in controlValue_t or a numeric parameter suitable for the control action.\n> \n> \\param dev\t\t\taddress of the device to control [0..getDeviceCount()-1].\n> \\param mode\t\tone of the defined control requests.\n> \\param value\t\tparameter value or one of the control status defined.\n> \\return false if parameter errors, true otherwise.\n>    \n",
    "lang": "c"
  },
  {
    "name": "control",
    "file": "[MD_MAX72xx.h](https://github.com/mongoose-os-libs/md-max72xx/blob/master/include/MD_MAX72xx.h)",
    "doc": "\n```c\ninline void control(controlRequest_t mode, int value) { control(0, getDeviceCount()-1, mode, value); };\n```\n> *\n> Set the control status of the specified parameter for all devices.\n> \n> Invokes the control function for each device in turn. as this is a wrapper for the\n> control(startDev, endDev, ...) methods, see the documentation for that method.\n> \n> \\param mode\t\tone of the defined control requests.\n> \\param value\t\tparameter value or one of the control status defined.\n> \\return No return value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "control",
    "file": "[MD_MAX72xx.h](https://github.com/mongoose-os-libs/md-max72xx/blob/master/include/MD_MAX72xx.h)",
    "doc": "\n```c\nbool control(uint8_t startDev, uint8_t endDev, controlRequest_t mode, int value);\n```\n> *\n> Set the control status of the specified parameter for contiguous subset of devices.\n> \n> Invokes the control function for each device in turn for the devices in the subset.\n> See documentation for the control() method.\n> \n> \\param startDev\tthe first device for the transformation [0..getDeviceCount()-1]\n> \\param endDev\t\tthe last device for the transformation [0..getDeviceCount()-1]\n> \\param mode\t\tone of the defined control requests.\n> \\param value\t\tparameter value or one of the control status defined.\n> \\return false if parameter errors, true otherwise.\n>    \n",
    "lang": "c"
  },
  {
    "name": "getDeviceCount",
    "file": "[MD_MAX72xx.h](https://github.com/mongoose-os-libs/md-max72xx/blob/master/include/MD_MAX72xx.h)",
    "doc": "\n```c\nuint8_t getDeviceCount(void) { return(_maxDevices); };\n```\n> *\n> Gets the number of devices attached to this class instance.\n> \n> \\return uint8_t representing the number of devices attached to this object.\n>    \n",
    "lang": "c"
  },
  {
    "name": "getColumnCount",
    "file": "[MD_MAX72xx.h](https://github.com/mongoose-os-libs/md-max72xx/blob/master/include/MD_MAX72xx.h)",
    "doc": "\n```c\nuint16_t getColumnCount(void) { return(_maxDevices*COL_SIZE); };\n```\n> *\n> Gets the maximum number of columns for devices attached to this class instance.\n> \n> \\return uint16_t representing the number of columns.\n>    \n",
    "lang": "c"
  },
  {
    "name": "setShiftDataInCallback",
    "file": "[MD_MAX72xx.h](https://github.com/mongoose-os-libs/md-max72xx/blob/master/include/MD_MAX72xx.h)",
    "doc": "\n```c\nvoid setShiftDataInCallback(uint8_t (*cb)(uint8_t dev, transformType_t t)) { _cbShiftDataIn = cb; };\n```\n> *\n> Set the Shift Data In callback function.\n> \n> The callback function is called from the library when a transform shift left\n> or shift right operation is executed and the library needs to obtain data for\n> the end element of the shift (ie, conceptually this is the new data that is\n> shifted 'into' the display). The callback function is invoked when\n> - WRAPAROUND is not active, as the data would automatically supplied within the library.\n> - the call to transform() is global (ie, not for an individual buffer).\n> \n> The callback function takes 2 parameters:\n> - the device number requesting the data [0..getDeviceCount()-1]\n> - one of the transformation types in transformType_t) that tells the callback function\n> what shift is being performed\n> The return value is the data for the column to be shifted into the display.\n> \n> \\param cb\tthe address of the function to be called from the library.\n> \\return No return data\n>    \n",
    "lang": "c"
  },
  {
    "name": "setShiftDataOutCallback",
    "file": "[MD_MAX72xx.h](https://github.com/mongoose-os-libs/md-max72xx/blob/master/include/MD_MAX72xx.h)",
    "doc": "\n```c\nvoid setShiftDataOutCallback(void (*cb)(uint8_t dev, transformType_t t, uint8_t colData)) { _cbShiftDataOut = cb; };\n```\n> *\n> Set the Shift Data Out callback function.\n> \n> The callback function is called from the library when a transform shift left\n> or shift right operation is executed and the library is about to discard the data for\n> the first element of the shift (ie, conceptually this is the data that 'falls' off\n> the front end of the scrolling display). The callback function is invoked when\n> - WRAPAROUND is not active, as the data would automatically supplied to the tail end.\n> - the call to transform() is global (ie, not for an individual buffer).\n> \n> The callback function is with supplied 3 parameters, with no return value required:\n> - the device number that is the source of the data [0..getDeviceCount()-1]\n> - one of the transformation types transformType_t that tells the callback\n> function the type of shifting being executed\n> - the data for the column being shifted out\n> \n> \\param cb\tthe address of the function to be called from the library.\n> \\return No return data\n>    \n",
    "lang": "c"
  },
  {
    "name": "clear",
    "file": "[MD_MAX72xx.h](https://github.com/mongoose-os-libs/md-max72xx/blob/master/include/MD_MAX72xx.h)",
    "doc": "\n```c\ninline void clear(void) { clear(0, getDeviceCount()-1); };\n```\n> *\n> Clear all the display data on all the display devices.\n> \n> \\return No return value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "clear",
    "file": "[MD_MAX72xx.h](https://github.com/mongoose-os-libs/md-max72xx/blob/master/include/MD_MAX72xx.h)",
    "doc": "\n```c\nvoid clear(uint8_t startDev, uint8_t endDev);\n```\n> *\n> Clear all the display data on a subset of devices.\n> \n> endDev must be greater than or equal to startDev.\n> \n> \\param startDev\tthe first device to clear [0..getDeviceCount()-1]\n> \\param endDev\t\tthe last device to clear [0..getDeviceCount()-1]\n> \\return No return value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "drawLine",
    "file": "[MD_MAX72xx.h](https://github.com/mongoose-os-libs/md-max72xx/blob/master/include/MD_MAX72xx.h)",
    "doc": "\n```c\nbool drawLine(uint8_t r1, uint16_t c1, uint8_t r2, uint16_t c2, bool state);\n```\n> *\n> Draw a line between two points on the display\n> \n> Draw a line between the specified points. The LED will be turned on or\n> off depending on the value supplied. The column number will be dereferenced\n> into the device and column within the device, allowing the LEDs to be treated\n> as a continuous pixel field.\n> \n> \\param r1\t\tstarting row coordinate for the point [0..ROW_SIZE-1].\n> \\param c1\t\tstarting column coordinate for the point [0..getColumnCount()-1].\n> \\param r2\t\tending row coordinate for the point [0..ROW_SIZE-1].\n> \\param c2\t\tending column coordinate for the point [0..getColumnCount())-1].\n> \\param state\ttrue - switch on; false - switch off.\n> \\return false if parameter errors, true otherwise.\n>    \n",
    "lang": "c"
  },
  {
    "name": "getBuffer",
    "file": "[MD_MAX72xx.h](https://github.com/mongoose-os-libs/md-max72xx/blob/master/include/MD_MAX72xx.h)",
    "doc": "\n```c\nbool getBuffer(uint16_t col, uint8_t size, uint8_t *pd);\n```\n> *\n> Load a bitmap from the display buffers to a user buffer.\n> \n> Allows the calling program to read bitmaps (characters or graphic)\n> elements from the library display buffers. The data buffer\n> pointer should be a block of uint8_t data of size elements that will\n> contain the returned data.\n> \n> \\param col\t\taddress of the display column [0..getColumnCount()-1].\n> \\param size\tnumber of columns of data to return.\n> \\param *pd\t\tPointer to a data buffer [0..size-1].\n> \\return false if parameter errors, true otherwise. If true, data will be in the buffer at *pd.\n>    \n",
    "lang": "c"
  },
  {
    "name": "getColumn",
    "file": "[MD_MAX72xx.h](https://github.com/mongoose-os-libs/md-max72xx/blob/master/include/MD_MAX72xx.h)",
    "doc": "\n```c\nuint8_t getColumn(uint8_t c) { return getColumn((c / COL_SIZE), c % COL_SIZE); };\n```\n> *\n> Get the LEDS status for the specified column.\n> \n> This method operates on a specific buffer\n> \n> This method operates on one column, getting the bit field value of\n> the LEDs in the column. The column is referenced with the absolute column\n> number (ie, the device number is inferred from the column).\n> \n> \\param c\t\tcolumn which is to be set [0..getColumnCount()-1].\n> \\return uint8_t value with each bit set to 1 if the corresponding LED is lit. 0 is returned for parameter error.\n>    \n",
    "lang": "c"
  },
  {
    "name": "getPoint",
    "file": "[MD_MAX72xx.h](https://github.com/mongoose-os-libs/md-max72xx/blob/master/include/MD_MAX72xx.h)",
    "doc": "\n```c\nbool getPoint(uint8_t r, uint16_t c);\n```\n> *\n> Get the status of a single LED, addressed as a pixel.\n> \n> The method will get the status of a specific LED element based on its\n> coordinate position. The column number is dereferenced into the device\n> and column within the device, allowing the LEDs to be treated as a\n> continuous pixel field.\n> \n> \\param r\t\trow coordinate for the point [0..ROW_SIZE-1].\n> \\param c\t\tcolumn coordinate for the point [0..getColumnCount()-1].\n> \\return true if LED is on, false if off or parameter errors.\n>    \n",
    "lang": "c"
  },
  {
    "name": "setBuffer",
    "file": "[MD_MAX72xx.h](https://github.com/mongoose-os-libs/md-max72xx/blob/master/include/MD_MAX72xx.h)",
    "doc": "\n```c\nbool setBuffer(uint16_t col, uint8_t size, uint8_t *pd);\n```\n> *\n> Load a bitfield from the user buffer to a display buffer.\n> \n> Allows the calling program to define bitmaps (characters or graphic)\n> elements and pass them to the library for display. The data buffer\n> pointer should be a block of uint8_t data of size elements that define\n> the bitmap.\n> \n> \\param col\t\taddress of the display column [0..getColumnCount()-1].\n> \\param size\tnumber of columns of data following.\n> \\param *pd\t\tPointer to a data buffer [0..size-1].\n> \\return false if parameter errors, true otherwise.\n>    \n",
    "lang": "c"
  },
  {
    "name": "setColumn",
    "file": "[MD_MAX72xx.h](https://github.com/mongoose-os-libs/md-max72xx/blob/master/include/MD_MAX72xx.h)",
    "doc": "\n```c\nbool setColumn(uint8_t c, uint8_t value) { return setColumn((c / COL_SIZE), c % COL_SIZE, value); };\n```\n> *\n> Set all LEDs in a specific column to a new state.\n> \n> This method operates on one column, setting the value of the LEDs in\n> the column to the specified value bitfield. The column is\n> referenced with the absolute column number (ie, the device number is\n> inferred from the column). The method is useful for drawing vertical\n> lines and patterns when the display is being treated as a pixel field.\n> The least significant bit of the value is the lowest row number.\n> \n> \\param c\t\tcolumn which is to be set [0..getColumnCount()-1].\n> \\param value\teach bit set to 1 will light up the corresponding LED.\n> \\return false if parameter errors, true otherwise.\n>    \n",
    "lang": "c"
  },
  {
    "name": "setPoint",
    "file": "[MD_MAX72xx.h](https://github.com/mongoose-os-libs/md-max72xx/blob/master/include/MD_MAX72xx.h)",
    "doc": "\n```c\nbool setPoint(uint8_t r, uint16_t c, bool state);\n```\n> *\n> Set the status of a single LED, addressed as a pixel.\n> \n> The method will set the value of a specific LED element based on its\n> coordinate position. The LED will be turned on or off depending on the\n> value supplied. The column number is dereferenced into the device and\n> column within the device, allowing the LEDs to be treated as a\n> continuous pixel field.\n> \n> \\param r\t\trow coordinate for the point [0..ROW_SIZE-1].\n> \\param c\t\tcolumn coordinate for the point [0..getColumnCount()-1].\n> \\param state\ttrue - switch on; false - switch off.\n> \\return false if parameter errors, true otherwise.\n>    \n",
    "lang": "c"
  },
  {
    "name": "setRow",
    "file": "[MD_MAX72xx.h](https://github.com/mongoose-os-libs/md-max72xx/blob/master/include/MD_MAX72xx.h)",
    "doc": "\n```c\ninline bool setRow(uint8_t r, uint8_t value) { return setRow(0, getDeviceCount()-1, r, value); };\n```\n> *\n> Set all LEDs in a row to a new state on all devices.\n> \n> This method operates on all devices, setting the value of the LEDs in\n> the row to the specified value bit field. The method is useful for\n> drawing patterns and lines horizontally across on the entire display.\n> The least significant bit of the value is the lowest column number.\n> \n> \\param r\t   row which is to be set [0..ROW_SIZE-1].\n> \\param value  each bit set to 1 will light up the corresponding LED on each device.\n> \\return false if parameter errors, true otherwise.\n>    \n",
    "lang": "c"
  },
  {
    "name": "setRow",
    "file": "[MD_MAX72xx.h](https://github.com/mongoose-os-libs/md-max72xx/blob/master/include/MD_MAX72xx.h)",
    "doc": "\n```c\nbool setRow(uint8_t startDev, uint8_t endDev, uint8_t r, uint8_t value);\n```\n> *\n> Set all LEDs in a row to a new state on contiguous subset of devices.\n> \n> This method operates on a contiguous subset of devices, setting the value\n> of the LEDs in the row to the specified value bit field. The method is useful for\n> drawing patterns and lines horizontally across specific devices only.\n> endDev must be greater than or equal to startDev.\n> The least significant bit of the value is the lowest column number.\n> \n> \\param startDev\tthe first device for the transformation [0..getDeviceCount()-1]\n> \\param endDev\t\tthe last device for the transformation [0..getDeviceCount()-1]\n> \\param r\t\t\trow which is to be set [0..ROW_SIZE-1].\n> \\param value\t\teach bit set to 1 will light up the corresponding LED on each device.\n> \\return false if parameter errors, true otherwise.\n>    \n",
    "lang": "c"
  },
  {
    "name": "transform",
    "file": "[MD_MAX72xx.h](https://github.com/mongoose-os-libs/md-max72xx/blob/master/include/MD_MAX72xx.h)",
    "doc": "\n```c\ninline bool transform(transformType_t ttype) { return transform(0, getDeviceCount()-1, ttype); };\n```\n> *\n> Apply a transformation to the data in all the devices.\n> \n> The buffers for all devices can be transformed using one of the enumerated\n> transformations in transformType_t. The transformation is carried across\n> device boundaries (ie, there is overflow to an adjacent devices if appropriate).\n> \n> \\param ttype  one of the transformation types in transformType_t.\n> \\return false if parameter errors, true otherwise.\n>    \n",
    "lang": "c"
  },
  {
    "name": "transform",
    "file": "[MD_MAX72xx.h](https://github.com/mongoose-os-libs/md-max72xx/blob/master/include/MD_MAX72xx.h)",
    "doc": "\n```c\nbool transform(uint8_t startDev, uint8_t endDev, transformType_t ttype);\n```\n> *\n> Apply a transformation to the data in contiguous subset of devices.\n> \n> The buffers for all devices in the subset can be transformed using one of the enumerated\n> transformations in transformType_t. The transformation is carried across\n> device boundaries (ie, there is overflow to an adjacent devices if appropriate).\n> endDev must be greater than or equal to startDev.\n> \n> \\param startDev\tthe first device for the transformation [0..getDeviceCount()-1]\n> \\param endDev\t\tthe last device for the transformation [0..getDeviceCount()-1]\n> \\param ttype\t\tone of the transformation types in transformType_t.\n> \\return false if parameter errors, true otherwise.\n>    \n",
    "lang": "c"
  },
  {
    "name": "update",
    "file": "[MD_MAX72xx.h](https://github.com/mongoose-os-libs/md-max72xx/blob/master/include/MD_MAX72xx.h)",
    "doc": "\n```c\nvoid update(controlValue_t mode) { control(UPDATE, mode); };\n```\n> *\n> Turn auto display updates on or off.\n> \n> Turn auto updates on and off, as required. When auto updates are turned OFF the\n> display will not update after each operation. Display updates can be forced at any\n> time using using a call to update() with no parameters.\n> \n> This function is a convenience wrapper for the more general control() function call.\n> \n> \\param mode\tone of the types in controlValue_t (ON/OFF).\n> \\return No return value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "update",
    "file": "[MD_MAX72xx.h](https://github.com/mongoose-os-libs/md-max72xx/blob/master/include/MD_MAX72xx.h)",
    "doc": "\n```c\nvoid update(void) { flushBufferAll(); };\n```\n> *\n> Force an update of all devices\n> \n> Used when auto updates have been turned off through the control\n> method. This will force all buffered changes to be written to\n> all the connected devices.\n> \n> \\return no return value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "wraparound",
    "file": "[MD_MAX72xx.h](https://github.com/mongoose-os-libs/md-max72xx/blob/master/include/MD_MAX72xx.h)",
    "doc": "\n```c\nvoid wraparound(controlValue_t mode) { control(WRAPAROUND, mode); };\n  /** @} */\n```\n> *\n> Turn display wraparound on or off.\n> \n> When shifting left or right, up or down, the outermost edge is normally lost and a blank\n> row or column inserted on the opposite side. If this options is enabled, the edge is wrapped\n> around to the opposite side.\n> \n> This function is a convenience wrapper for the more general control() function call.\n> \n> \\param mode\tone of the types in controlValue_t (ON/OFF).\n> \\return No return value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "clear",
    "file": "[MD_MAX72xx.h](https://github.com/mongoose-os-libs/md-max72xx/blob/master/include/MD_MAX72xx.h)",
    "doc": "\n```c\nbool clear(uint8_t buf);\n```\n> *\n> Clear all display data in the specified buffer.\n> \n> \\param buf\t\taddress of the buffer to clear [0..getDeviceCount()-1].\n> \\return false if parameter errors, true otherwise.\n>    \n",
    "lang": "c"
  },
  {
    "name": "getColumn",
    "file": "[MD_MAX72xx.h](https://github.com/mongoose-os-libs/md-max72xx/blob/master/include/MD_MAX72xx.h)",
    "doc": "\n```c\nuint8_t getColumn(uint8_t buf, uint8_t c);\n```\n> *\n> Get the state of the LEDs in a specific column.\n> \n> This method operates on the specific buffer, returning the bit field value of\n> the LEDs in the column.\n> \n> \\param buf\t\taddress of the display [0..getDeviceCount()-1].\n> \\param c\t\tcolumn which is to be set [0..COL_SIZE-1].\n> \\return uint8_t value with each bit set to 1 if the corresponding LED is lit. 0 is returned for parameter error.\n>    \n",
    "lang": "c"
  },
  {
    "name": "getRow",
    "file": "[MD_MAX72xx.h](https://github.com/mongoose-os-libs/md-max72xx/blob/master/include/MD_MAX72xx.h)",
    "doc": "\n```c\nuint8_t getRow(uint8_t buf, uint8_t r);\n```\n> *\n> Get the state of the LEDs in a specified row.\n> \n> This method operates on the specific buffer, returning the bit field value of\n> the LEDs in the row.\n> \n> \\param buf\t\taddress of the display [0..getDeviceCount()-1].\n> \\param r\t\trow which is to be set [0..ROW_SIZE-1].\n> \\return uint8_t value with each bit set to 1 if the corresponding LED is lit. 0 is returned for parameter error.\n>    \n",
    "lang": "c"
  },
  {
    "name": "setColumn",
    "file": "[MD_MAX72xx.h](https://github.com/mongoose-os-libs/md-max72xx/blob/master/include/MD_MAX72xx.h)",
    "doc": "\n```c\nbool setColumn(uint8_t buf, uint8_t c, uint8_t value);\n```\n> *\n> Set all LEDs in a column to a new state.\n> \n> This method operates on a specific buffer, setting the value of the LEDs in\n> the column to the specified value bit field. The method is useful for\n> drawing patterns and lines vertically on the display device.\n> The least significant bit of the value is the lowest column number.\n> \n> \\param buf\t\taddress of the display [0..getDeviceCount()-1].\n> \\param c\t\tcolumn which is to be set [0..COL_SIZE-1].\n> \\param value   each bit set to 1 will light up the\tcorresponding LED.\n> \\return false if parameter errors, true otherwise.\n>    \n",
    "lang": "c"
  },
  {
    "name": "setRow",
    "file": "[MD_MAX72xx.h](https://github.com/mongoose-os-libs/md-max72xx/blob/master/include/MD_MAX72xx.h)",
    "doc": "\n```c\nbool setRow(uint8_t buf, uint8_t r, uint8_t value);\n```\n> *\n> Set all LEDs in a row to a new state.\n> \n> This method operates on a specific device, setting the value of the LEDs in\n> the row to the specified value bit field. The method is useful for\n> drawing patterns and lines horizontally across the display device.\n> The least significant bit of the value is the lowest row number.\n> \n> \\param buf\t\taddress of the display [0..getDeviceCount()-1].\n> \\param r\t\trow which is to be set [0..ROW_SIZE-1].\n> \\param value   each bit set to 1 within this byte will light up the corresponding LED.\n> \\return false if parameter errors, true otherwise.\n>    \n",
    "lang": "c"
  },
  {
    "name": "transform",
    "file": "[MD_MAX72xx.h](https://github.com/mongoose-os-libs/md-max72xx/blob/master/include/MD_MAX72xx.h)",
    "doc": "\n```c\nbool transform(uint8_t buf, transformType_t ttype);\n```\n> *\n> Apply a transformation to the data in the specified device.\n> \n> The buffer for one device can be transformed using one of the enumerated\n> transformations in transformType_t. The transformation is limited to the\n> nominated device buffer only (ie, there is no overflow to an adjacent device).\n> \n> \\param buf\t   address of the display [0..getBufferCount()-1].\n> \\param ttype  one of the transformation types in transformType_t.\n> \\return false if parameter errors, true otherwise.\n>    \n",
    "lang": "c"
  },
  {
    "name": "update",
    "file": "[MD_MAX72xx.h](https://github.com/mongoose-os-libs/md-max72xx/blob/master/include/MD_MAX72xx.h)",
    "doc": "\n```c\nvoid update(uint8_t buf) { flushBuffer(buf); };\n  /** @} */\n```\n> *\n> Force an update of one buffer.\n> \n> Used when auto updates have been turned off through the control()\n> method. This will force all buffered display changes to be written to\n> the specified device at the same time.\n> Note that control() messages are not buffered but cause immediate action.\n> \n> \\param buf\taddress of the display [0..getBufferCount()-1].\n> \\return No return value.\n>    \n",
    "lang": "c"
  },
  {
    "name": "getChar",
    "file": "[MD_MAX72xx.h](https://github.com/mongoose-os-libs/md-max72xx/blob/master/include/MD_MAX72xx.h)",
    "doc": "\n```c\nuint8_t getChar(uint8_t c, uint8_t size, uint8_t *buf);\n```\n> *\n> Load a character from the font data into a user buffer.\n> \n> Copy the bitmap for a library font character (current font set by setFont()) and\n> return it in the data area passed by the user. If the user buffer is not large\n> enough, only the first size elements are copied to the buffer.\n> \n> NOTE: This function is only available if the library defined value\n> USE_LOCAL_FONT is set to 1.\n> \n> \\param c\t\tthe character to retrieve.\n> \\param size\tthe size of the user buffer in unit8_t units.\n> \\param buf\t\taddress of the user buffer supplied.\n> \\return width (in columns) of the character, 0 if parameter errors.\n>    \n",
    "lang": "c"
  },
  {
    "name": "setChar",
    "file": "[MD_MAX72xx.h](https://github.com/mongoose-os-libs/md-max72xx/blob/master/include/MD_MAX72xx.h)",
    "doc": "\n```c\nuint8_t setChar(uint16_t col, uint8_t c);\n```\n> *\n> Load a character from the font data starting at a specific column.\n> \n> Load a character from the font table directly into the display at the column\n> specified. The currently selected font table is used as the source.\n> \n> NOTE: This function is only available if the library defined value\n> USE_LOCAL_FONT is set to 1.\n> \n> \\param col\t\tcolumn of the display in the range accepted [0..getColumnCount()-1].\n> \\param c\t\tthe character to display.\n> \\return width (in columns) of the character, 0 if parameter errors.\n>    \n",
    "lang": "c"
  },
  {
    "name": "setFont",
    "file": "[MD_MAX72xx.h](https://github.com/mongoose-os-libs/md-max72xx/blob/master/include/MD_MAX72xx.h)",
    "doc": "\n```c\nbool setFont(fontType_t *f);\n```\n> *\n> Set the current font table.\n> \n> Font data is stored in PROGMEM, in the format described elsewhere in the\n> documentation. All characters retrieved or used after this call will use\n> the nominated font (default or user defined). To specify a user defined\n> character set, pass the PROGMEM address of the font table. Passing a nullptr\n> resets the font table to the library default table.\n> \n> This function also causes the font index table to be recreated if the\n> library defined value USE_INDEX_TABLE is set to 1.\n> \n> NOTE: This function is only available if the library defined value\n> USE_LOCAL_FONT is set to 1.\n> \n> \\param f\tfontType_t pointer to the table of font data in PROGMEM or nullptr.\n> \\return false if parameter errors, true otherwise.\n>    \n",
    "lang": "c"
  },
  {
    "name": "getMaxFontWidth",
    "file": "[MD_MAX72xx.h](https://github.com/mongoose-os-libs/md-max72xx/blob/master/include/MD_MAX72xx.h)",
    "doc": "\n```c\nuint8_t getMaxFontWidth(void);\n```\n> *\n> Get the maximum width character for the font.\n> \n> Returns the number of columns for the widest character in the currently\n> selected font table. Useful to allocated buffers of the right size before \n> loading characters from the font table.\n> \n> NOTE: This function is only available if the library defined value\n> USE_LOCAL_FONT is set to 1.\n> \n> \\return number of columns (width) for the widest character.\n>   \n",
    "lang": "c"
  },
  {
    "name": "getFont",
    "file": "[MD_MAX72xx.h](https://github.com/mongoose-os-libs/md-max72xx/blob/master/include/MD_MAX72xx.h)",
    "doc": "\n```c\nfontType_t *getFont(void) { return(_fontData); };\n#endif // USE_LOCAL_FONT\n  /** @} */\n```\n> *\n> Get the pointer to current font table.\n> \n> Returns the pointer to the current font table. Useful if user code needs \n> to replace the current font temporarily and then restore previous font.\n> \n> NOTE: This function is only available if the library defined value\n> USE_LOCAL_FONT is set to 1.\n> \n> \\return pointer to the start of the font table in PROGMEM.\n>    \n",
    "lang": "c"
  },
  {
    "name": "(*_cbShiftDataIn)",
    "file": "[MD_MAX72xx.h](https://github.com/mongoose-os-libs/md-max72xx/blob/master/include/MD_MAX72xx.h)",
    "doc": "\n```c\nuint8_t\t(*_cbShiftDataIn)(uint8_t dev, transformType_t t);\n  void\t\t(*_cbShiftDataOut)(uint8_t dev, transformType_t t, uint8_t colData);\n```\n> User callback function for shifting operations\n",
    "lang": "c"
  },
  {
    "name": "buildFontIndex",
    "file": "[MD_MAX72xx.h](https://github.com/mongoose-os-libs/md-max72xx/blob/master/include/MD_MAX72xx.h)",
    "doc": "\n```c\nvoid\t\tbuildFontIndex(void);\t\t\t// build a font index\n#endif\n```\n> find the character in the font data\n",
    "lang": "c"
  },
  {
    "name": "spiInit",
    "file": "[MD_MAX72xx.h](https://github.com/mongoose-os-libs/md-max72xx/blob/master/include/MD_MAX72xx.h)",
    "doc": "\n```c\nvoid spiInit(void);\t\t\t    // do the actual physical communications task\n  void spiSend(void);\t\t\t    // do the actual physical communications task\n  void spiSendArduino(void);\t// do the actual physical communications task\n  void spiClearBuffer(void);\t// clear the SPI send buffer\n  void controlHardware(uint8_t dev, controlRequest_t mode, int value);\t// set hardware control commands\n  void controlLibrary(controlRequest_t mode, int value);\t// set internal control commands\n```\n> Private functions\n",
    "lang": "c"
  },
  {
    "name": "flushBufferAll",
    "file": "[MD_MAX72xx.h](https://github.com/mongoose-os-libs/md-max72xx/blob/master/include/MD_MAX72xx.h)",
    "doc": "\n```c\nvoid flushBufferAll();\t\t\t  // determine what needs to be sent for all devices and transmit\n```\n> determine what needs to be sent for one device and transmit\n",
    "lang": "c"
  },
  {
    "name": "transformBuffer",
    "file": "[MD_MAX72xx.h](https://github.com/mongoose-os-libs/md-max72xx/blob/master/include/MD_MAX72xx.h)",
    "doc": "\n```c\nbool transformBuffer(uint8_t buf, transformType_t ttype);\t// internal transform function\n```\n> reverse the order of bits in the byte\n",
    "lang": "c"
  },
  {
    "name": "copyColumn",
    "file": "[MD_MAX72xx.h](https://github.com/mongoose-os-libs/md-max72xx/blob/master/include/MD_MAX72xx.h)",
    "doc": "\n```c\nbool copyColumn(uint8_t buf, uint8_t cSrc, uint8_t cDest);// copy a row from Src to Dest\n};\n```\n> copy a row from Src to Dest\n",
    "lang": "c"
  },
  {
    "name": "mgos_mdash_set_label",
    "file": "[mgos_mdash_api.h](https://github.com/mongoose-os-libs/mdash-api/blob/master/include/mgos_mdash_api.h)",
    "doc": "\n```c\nvoid mgos_mdash_set_label(const char *label);\n```\n>  set a device label \n",
    "lang": "c"
  },
  {
    "name": "mgos_mdash_widget_toggle_create",
    "file": "[mgos_mdash_api.h](https://github.com/mongoose-os-libs/mdash-api/blob/master/include/mgos_mdash_api.h)",
    "doc": "\n```c\nstruct mgos_mdash_widget *mgos_mdash_widget_toggle_create(const char *title,\n                                                          const char *key);\n```\n>  {\"type\": \"toggle\", \"title\": \"Switch LED on/off\", \"key\": \"led\"} \n",
    "lang": "c"
  },
  {
    "name": "mgos_mdash_widget_value_create",
    "file": "[mgos_mdash_api.h](https://github.com/mongoose-os-libs/mdash-api/blob/master/include/mgos_mdash_api.h)",
    "doc": "\n```c\nstruct mgos_mdash_widget *mgos_mdash_widget_value_create(const char *title,\n                                                         const char *key);\n```\n>  {\"type\": \"value\", \"title\": \"free RAM:\", \"key\": \"ram\"} \n",
    "lang": "c"
  },
  {
    "name": "mgos_mdash_widget_button_create",
    "file": "[mgos_mdash_api.h](https://github.com/mongoose-os-libs/mdash-api/blob/master/include/mgos_mdash_api.h)",
    "doc": "\n```c\nstruct mgos_mdash_widget *mgos_mdash_widget_button_create(const char *title,\n                                                          const char *method,\n                                                          const char *params,\n                                                          const char *icon);\n```\n>  {\"type\": \"button\", \"title\": \"reboot\", \"icon\": \"fa-power-off\", \"method\":\n>    \"Sys.Reboot\", \"params\": {}} \n",
    "lang": "c"
  },
  {
    "name": "mgos_mdash_widget_input_create",
    "file": "[mgos_mdash_api.h](https://github.com/mongoose-os-libs/mdash-api/blob/master/include/mgos_mdash_api.h)",
    "doc": "\n```c\nstruct mgos_mdash_widget *mgos_mdash_widget_input_create(const char *title,\n                                                         const char *key);\n```\n>  {\"type\": \"input\", \"icon\": \"fa-save\", title: \"Set LED pin\", \"key\": \"pin\"} \n",
    "lang": "c"
  },
  {
    "name": "mgos_mdash_widget_free",
    "file": "[mgos_mdash_api.h](https://github.com/mongoose-os-libs/mdash-api/blob/master/include/mgos_mdash_api.h)",
    "doc": "\n```c\nvoid mgos_mdash_widget_free(struct mgos_mdash_widget **widget);\n```\n>  free the widget \n",
    "lang": "c"
  },
  {
    "name": "mgos_mdash_create_ui",
    "file": "[mgos_mdash_api.h](https://github.com/mongoose-os-libs/mdash-api/blob/master/include/mgos_mdash_api.h)",
    "doc": "\n```c\nbool mgos_mdash_create_ui(const struct mgos_mdash_widgets *widgets);\n```\n>  create the mDash UI \n",
    "lang": "c"
  },
  {
    "name": "mgos_mdash_widgets_create",
    "file": "[mgos_mdash_api.h](https://github.com/mongoose-os-libs/mdash-api/blob/master/include/mgos_mdash_api.h)",
    "doc": "\n```c\nstruct mgos_mdash_widgets *mgos_mdash_widgets_create(size_t max_count);\n```\n>  create the widgets holder \n",
    "lang": "c"
  },
  {
    "name": "mgos_mdash_widgets_create_from_config",
    "file": "[mgos_mdash_api.h](https://github.com/mongoose-os-libs/mdash-api/blob/master/include/mgos_mdash_api.h)",
    "doc": "\n```c\nbool mgos_mdash_widgets_create_from_config(struct mgos_mdash_widgets **widgets);\n```\n>  create the widgets from config \n",
    "lang": "c"
  },
  {
    "name": "mgos_mdash_widgets_add_widget",
    "file": "[mgos_mdash_api.h](https://github.com/mongoose-os-libs/mdash-api/blob/master/include/mgos_mdash_api.h)",
    "doc": "\n```c\nvoid mgos_mdash_widgets_add_widget(struct mgos_mdash_widgets *widgets,\n                                   struct mgos_mdash_widget *widget);\n```\n>  add a widget \n",
    "lang": "c"
  },
  {
    "name": "mgos_mdash_widgets_free",
    "file": "[mgos_mdash_api.h](https://github.com/mongoose-os-libs/mdash-api/blob/master/include/mgos_mdash_api.h)",
    "doc": "\n```c\nvoid mgos_mdash_widgets_free(struct mgos_mdash_widgets *widgets);\n```\n>  free the widgets holder \n",
    "lang": "c"
  },
  {
    "name": "defined",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\n#if defined(__TINYC__) && (defined(__linux) || defined(__linux__))\n/* TODO: Work around \"error: include file 'sys\\utime.h' when compiling with tcc on Linux */\n#define MINIZ_NO_TIME\n#endif\n```\n> #define MINIZ_NO_MALLOC \n",
    "lang": "c"
  },
  {
    "name": "mz_free",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nvoid mz_free(void *p);\n```\n>  mz_free() internally uses the MZ_FREE() macro (which by default calls free() unless you've modified the MZ_MALLOC macro) to release a block allocated from the heap. \n",
    "lang": "c"
  },
  {
    "name": "mz_adler32",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nmz_ulong mz_adler32(mz_ulong adler, const unsigned char *ptr, size_t buf_len);\n```\n>  mz_adler32() returns the initial adler-32 value to use when called with ptr==NULL. \n",
    "lang": "c"
  },
  {
    "name": "mz_crc32",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nmz_ulong mz_crc32(mz_ulong crc, const unsigned char *ptr, size_t buf_len);\n```\n>  mz_crc32() returns the initial CRC-32 value to use when called with ptr==NULL. \n",
    "lang": "c"
  },
  {
    "name": "(*mz_alloc_func)",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\ntypedef void *(*mz_alloc_func)(void *opaque, size_t items, size_t size);\ntypedef void (*mz_free_func)(void *opaque, void *address);\ntypedef void *(*mz_realloc_func)(void *opaque, void *address, size_t items, size_t size);\n```\n>  Heap allocation callbacks.\n> Note that mz_alloc_func parameter types purpsosely differ from zlib's: items/size is size_t, not unsigned long. \n",
    "lang": "c"
  },
  {
    "name": "mz_version",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nconst char *mz_version(void);\n```\n>  Returns the version string of miniz.c. \n",
    "lang": "c"
  },
  {
    "name": "mz_deflateInit",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nint mz_deflateInit(mz_streamp pStream, int level);\n```\n>   MZ_MEM_ERROR on out of memory. \n",
    "lang": "c"
  },
  {
    "name": "mz_deflateInit2",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nint mz_deflateInit2(mz_streamp pStream, int level, int method, int window_bits, int mem_level, int strategy);\n```\n>    mem_level must be between [1, 9] (it's checked but ignored by miniz.c) \n",
    "lang": "c"
  },
  {
    "name": "mz_deflateReset",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nint mz_deflateReset(mz_streamp pStream);\n```\n>  Quickly resets a compressor without having to reallocate anything. Same as calling mz_deflateEnd() followed by mz_deflateInit()/mz_deflateInit2(). \n",
    "lang": "c"
  },
  {
    "name": "mz_deflate",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nint mz_deflate(mz_streamp pStream, int flush);\n```\n>    MZ_BUF_ERROR if no forward progress is possible because the input and/or output buffers are empty. (Fill up the input buffer or free up some output space and try again.) \n",
    "lang": "c"
  },
  {
    "name": "mz_deflateEnd",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nint mz_deflateEnd(mz_streamp pStream);\n```\n>   MZ_STREAM_ERROR if the stream is bogus. \n",
    "lang": "c"
  },
  {
    "name": "mz_deflateBound",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nmz_ulong mz_deflateBound(mz_streamp pStream, mz_ulong source_len);\n```\n>  mz_deflateBound() returns a (very) conservative upper bound on the amount of data that could be generated by deflate(), assuming flush is set to only MZ_NO_FLUSH or MZ_FINISH. \n",
    "lang": "c"
  },
  {
    "name": "mz_compress",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nint mz_compress(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len);\nint mz_compress2(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len, int level);\n```\n>  Returns MZ_OK on success, or one of the error codes from mz_deflate() on failure. \n",
    "lang": "c"
  },
  {
    "name": "mz_compressBound",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nmz_ulong mz_compressBound(mz_ulong source_len);\n```\n>  mz_compressBound() returns a (very) conservative upper bound on the amount of data that could be generated by calling mz_compress(). \n",
    "lang": "c"
  },
  {
    "name": "mz_inflateInit",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nint mz_inflateInit(mz_streamp pStream);\n```\n>  Initializes a decompressor. \n",
    "lang": "c"
  },
  {
    "name": "mz_inflateInit2",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nint mz_inflateInit2(mz_streamp pStream, int window_bits);\n```\n>  window_bits must be MZ_DEFAULT_WINDOW_BITS (to parse zlib header/footer) or -MZ_DEFAULT_WINDOW_BITS (raw deflate). \n",
    "lang": "c"
  },
  {
    "name": "mz_inflate",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nint mz_inflate(mz_streamp pStream, int flush);\n```\n>    with more input data, or with more room in the output buffer (except when using single call decompression, described above). \n",
    "lang": "c"
  },
  {
    "name": "mz_inflateEnd",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nint mz_inflateEnd(mz_streamp pStream);\n```\n>  Deinitializes a decompressor. \n",
    "lang": "c"
  },
  {
    "name": "mz_uncompress",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nint mz_uncompress(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len);\n```\n>  Returns MZ_OK on success, or one of the error codes from mz_inflate() on failure. \n",
    "lang": "c"
  },
  {
    "name": "mz_error",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nconst char *mz_error(int err);\n```\n>  Returns a string description of the specified error code, or NULL if the error code is invalid. \n",
    "lang": "c"
  },
  {
    "name": "tdefl_compress_mem_to_heap",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nvoid *tdefl_compress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags);\n```\n>   The caller must free() the returned block when it's no longer needed. \n",
    "lang": "c"
  },
  {
    "name": "tdefl_compress_mem_to_mem",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nsize_t tdefl_compress_mem_to_mem(void *pOut_buf, size_t out_buf_len, const void *pSrc_buf, size_t src_buf_len, int flags);\n```\n>  Returns 0 on failure. \n",
    "lang": "c"
  },
  {
    "name": "tdefl_write_image_to_png_file_in_memory_ex",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nvoid *tdefl_write_image_to_png_file_in_memory_ex(const void *pImage, int w, int h, int num_chans, size_t *pLen_out, mz_uint level, mz_bool flip);\nvoid *tdefl_write_image_to_png_file_in_memory(const void *pImage, int w, int h, int num_chans, size_t *pLen_out);\n```\n>   The caller must mz_free() the returned heap block (which will typically be larger than *pLen_out) when it's no longer needed. \n",
    "lang": "c"
  },
  {
    "name": "(*tdefl_put_buf_func_ptr)",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\ntypedef mz_bool (*tdefl_put_buf_func_ptr)(const void *pBuf, int len, void *pUser);\n```\n>  Output stream interface. The compressor uses this interface to write compressed data. It'll typically be called TDEFL_OUT_BUF_SIZE at a time. \n",
    "lang": "c"
  },
  {
    "name": "tdefl_compress_mem_to_output",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nmz_bool tdefl_compress_mem_to_output(const void *pBuf, size_t buf_len, tdefl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags);\n```\n>  tdefl_compress_mem_to_output() compresses a block to an output stream. The above helpers use this function internally. \n",
    "lang": "c"
  },
  {
    "name": "tdefl_init",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\ntdefl_status tdefl_init(tdefl_compressor *d, tdefl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags);\n```\n>  flags: See the above enums (TDEFL_HUFFMAN_ONLY, TDEFL_WRITE_ZLIB_HEADER, etc.) \n",
    "lang": "c"
  },
  {
    "name": "tdefl_compress",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\ntdefl_status tdefl_compress(tdefl_compressor *d, const void *pIn_buf, size_t *pIn_buf_size, void *pOut_buf, size_t *pOut_buf_size, tdefl_flush flush);\n```\n>  Compresses a block of data, consuming as much of the specified input buffer as possible, and writing as much compressed data to the specified output buffer as possible. \n",
    "lang": "c"
  },
  {
    "name": "tdefl_compress_buffer",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\ntdefl_status tdefl_compress_buffer(tdefl_compressor *d, const void *pIn_buf, size_t in_buf_size, tdefl_flush flush);\n```\n>  tdefl_compress_buffer() always consumes the entire input buffer. \n",
    "lang": "c"
  },
  {
    "name": "tdefl_create_comp_flags_from_zip_params",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nmz_uint tdefl_create_comp_flags_from_zip_params(int level, int window_bits, int strategy);\n```\n>  strategy may be either MZ_DEFAULT_STRATEGY, MZ_FILTERED, MZ_HUFFMAN_ONLY, MZ_RLE, or MZ_FIXED \n",
    "lang": "c"
  },
  {
    "name": "tdefl_compressor_alloc",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\ntdefl_compressor *tdefl_compressor_alloc();\nvoid tdefl_compressor_free(tdefl_compressor *pComp);\n```\n>  structure size and allocation mechanism. \n",
    "lang": "c"
  },
  {
    "name": "tinfl_decompress_mem_to_heap",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nvoid *tinfl_decompress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags);\n```\n>   The caller must call mz_free() on the returned block when it's no longer needed. \n",
    "lang": "c"
  },
  {
    "name": "((size_t)",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\n#define TINFL_DECOMPRESS_MEM_TO_MEM_FAILED ((size_t)(-1))\nsize_t tinfl_decompress_mem_to_mem(void *pOut_buf, size_t out_buf_len, const void *pSrc_buf, size_t src_buf_len, int flags);\n```\n>  Returns TINFL_DECOMPRESS_MEM_TO_MEM_FAILED on failure, or the number of bytes written on success. \n",
    "lang": "c"
  },
  {
    "name": "(*tinfl_put_buf_func_ptr)",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\ntypedef int (*tinfl_put_buf_func_ptr)(const void *pBuf, int len, void *pUser);\nint tinfl_decompress_mem_to_callback(const void *pIn_buf, size_t *pIn_buf_size, tinfl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags);\n```\n>  Returns 1 on success or 0 on failure. \n",
    "lang": "c"
  },
  {
    "name": "tinfl_decompressor_alloc",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\ntinfl_decompressor *tinfl_decompressor_alloc();\nvoid tinfl_decompressor_free(tinfl_decompressor *pDecomp);\n```\n>  structure size and allocation mechanism. \n",
    "lang": "c"
  },
  {
    "name": "tinfl_init",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\n#define tinfl_init(r)     \\\n    do                    \\\n    {                     \\\n        (r)->m_state = 0; \\\n    }                     \\\n    MZ_MACRO_END\n#define tinfl_get_adler32(r) (r)->m_check_adler32\n```\n>  Initializes the decompressor to its initial state. \n",
    "lang": "c"
  },
  {
    "name": "tinfl_decompress",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\ntinfl_status tinfl_decompress(tinfl_decompressor *r, const mz_uint8 *pIn_buf_next, size_t *pIn_buf_size, mz_uint8 *pOut_buf_start, mz_uint8 *pOut_buf_next, size_t *pOut_buf_size, const mz_uint32 decomp_flags);\n```\n>  This is a universal API, i.e. it can be used as a building block to build any desired higher level decompression API. In the limit case, it can be called once per every byte input or output. \n",
    "lang": "c"
  },
  {
    "name": "mz_zip_reader_init",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nmz_bool mz_zip_reader_init(mz_zip_archive *pZip, mz_uint64 size, mz_uint flags);\n```\n>  These functions read and validate the archive's central directory. \n",
    "lang": "c"
  },
  {
    "name": "mz_zip_reader_init_file",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nmz_bool mz_zip_reader_init_file(mz_zip_archive *pZip, const char *pFilename, mz_uint32 flags);\nmz_bool mz_zip_reader_init_file_v2(mz_zip_archive *pZip, const char *pFilename, mz_uint flags, mz_uint64 file_start_ofs, mz_uint64 archive_size);\n```\n>  actual_archive_size is the true total size of the archive, which may be smaller than the file's actual size on disk. If zero the entire file is treated as the archive. \n",
    "lang": "c"
  },
  {
    "name": "mz_zip_reader_init_cfile",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nmz_bool mz_zip_reader_init_cfile(mz_zip_archive *pZip, MZ_FILE *pFile, mz_uint64 archive_size, mz_uint flags);\n#endif\n```\n>  The FILE will NOT be closed when mz_zip_reader_end() is called. \n",
    "lang": "c"
  },
  {
    "name": "mz_zip_reader_end",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nmz_bool mz_zip_reader_end(mz_zip_archive *pZip);\n```\n>  Ends archive reading, freeing all allocations, and closing the input archive file if mz_zip_reader_init_file() was used. \n",
    "lang": "c"
  },
  {
    "name": "mz_zip_zero_struct",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nvoid mz_zip_zero_struct(mz_zip_archive *pZip);\n```\n>  Important: This must be done before passing the struct to any mz_zip functions. \n",
    "lang": "c"
  },
  {
    "name": "mz_zip_reader_get_num_files",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nmz_uint mz_zip_reader_get_num_files(mz_zip_archive *pZip);\n```\n>  Returns the total number of files in the archive. \n",
    "lang": "c"
  },
  {
    "name": "mz_zip_read_archive_data",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nsize_t mz_zip_read_archive_data(mz_zip_archive *pZip, mz_uint64 file_ofs, void *pBuf, size_t n);\n```\n>  Reads n bytes of raw archive data, starting at file offset file_ofs, to pBuf. \n",
    "lang": "c"
  },
  {
    "name": "mz_zip_locate_file",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nint mz_zip_locate_file(mz_zip_archive *pZip, const char *pName, const char *pComment, mz_uint flags);\n/* Returns MZ_FALSE if the file cannot be found. */\nmz_bool mz_zip_locate_file_v2(mz_zip_archive *pZip, const char *pName, const char *pComment, mz_uint flags, mz_uint32 *pIndex);\n```\n>  Returns -1 if the file cannot be found. \n",
    "lang": "c"
  },
  {
    "name": "mz_zip_set_last_error",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nmz_zip_error mz_zip_set_last_error(mz_zip_archive *pZip, mz_zip_error err_num);\nmz_zip_error mz_zip_peek_last_error(mz_zip_archive *pZip);\nmz_zip_error mz_zip_clear_last_error(mz_zip_archive *pZip);\nmz_zip_error mz_zip_get_last_error(mz_zip_archive *pZip);\nconst char *mz_zip_get_error_string(mz_zip_error mz_err);\n```\n>  Note that the m_last_error functionality is not thread safe. \n",
    "lang": "c"
  },
  {
    "name": "mz_zip_reader_is_file_a_directory",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nmz_bool mz_zip_reader_is_file_a_directory(mz_zip_archive *pZip, mz_uint file_index);\n```\n>  MZ_TRUE if the archive file entry is a directory entry. \n",
    "lang": "c"
  },
  {
    "name": "mz_zip_reader_is_file_encrypted",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nmz_bool mz_zip_reader_is_file_encrypted(mz_zip_archive *pZip, mz_uint file_index);\n```\n>  MZ_TRUE if the file is encrypted/strong encrypted. \n",
    "lang": "c"
  },
  {
    "name": "mz_zip_reader_is_file_supported",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nmz_bool mz_zip_reader_is_file_supported(mz_zip_archive *pZip, mz_uint file_index);\n```\n>  MZ_TRUE if the compression method is supported, and the file is not encrypted, and the file is not a compressed patch file. \n",
    "lang": "c"
  },
  {
    "name": "mz_zip_reader_get_filename",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nmz_uint mz_zip_reader_get_filename(mz_zip_archive *pZip, mz_uint file_index, char *pFilename, mz_uint filename_buf_size);\n```\n>  Returns the number of bytes written to pFilename, or if filename_buf_size is 0 this function returns the number of bytes needed to fully store the filename. \n",
    "lang": "c"
  },
  {
    "name": "mz_zip_reader_locate_file",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nint mz_zip_reader_locate_file(mz_zip_archive *pZip, const char *pName, const char *pComment, mz_uint flags);\nint mz_zip_reader_locate_file_v2(mz_zip_archive *pZip, const char *pName, const char *pComment, mz_uint flags, mz_uint32 *file_index);\n```\n>  Returns -1 if the file cannot be found. \n",
    "lang": "c"
  },
  {
    "name": "mz_zip_reader_file_stat",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nmz_bool mz_zip_reader_file_stat(mz_zip_archive *pZip, mz_uint file_index, mz_zip_archive_file_stat *pStat);\n```\n>  Returns detailed information about an archive file entry. \n",
    "lang": "c"
  },
  {
    "name": "mz_zip_is_zip64",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nmz_bool mz_zip_is_zip64(mz_zip_archive *pZip);\n```\n>  A file is considered zip64 if it contained a zip64 end of central directory marker, or if it contained any zip64 extended file information fields in the central directory. \n",
    "lang": "c"
  },
  {
    "name": "mz_zip_get_central_dir_size",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nsize_t mz_zip_get_central_dir_size(mz_zip_archive *pZip);\n```\n>  The current max supported size is <= MZ_UINT32_MAX. \n",
    "lang": "c"
  },
  {
    "name": "mz_zip_reader_extract_to_mem_no_alloc",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nmz_bool mz_zip_reader_extract_to_mem_no_alloc(mz_zip_archive *pZip, mz_uint file_index, void *pBuf, size_t buf_size, mz_uint flags, void *pUser_read_buf, size_t user_read_buf_size);\nmz_bool mz_zip_reader_extract_file_to_mem_no_alloc(mz_zip_archive *pZip, const char *pFilename, void *pBuf, size_t buf_size, mz_uint flags, void *pUser_read_buf, size_t user_read_buf_size);\n```\n>  There must be at least enough room on the stack to store the inflator's state (~34KB or so). \n",
    "lang": "c"
  },
  {
    "name": "mz_zip_reader_extract_to_mem",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nmz_bool mz_zip_reader_extract_to_mem(mz_zip_archive *pZip, mz_uint file_index, void *pBuf, size_t buf_size, mz_uint flags);\nmz_bool mz_zip_reader_extract_file_to_mem(mz_zip_archive *pZip, const char *pFilename, void *pBuf, size_t buf_size, mz_uint flags);\n```\n>  Extracts a archive file to a memory buffer. \n",
    "lang": "c"
  },
  {
    "name": "mz_zip_reader_extract_to_heap",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nvoid *mz_zip_reader_extract_to_heap(mz_zip_archive *pZip, mz_uint file_index, size_t *pSize, mz_uint flags);\nvoid *mz_zip_reader_extract_file_to_heap(mz_zip_archive *pZip, const char *pFilename, size_t *pSize, mz_uint flags);\n```\n>  Returns NULL and sets the last error on failure. \n",
    "lang": "c"
  },
  {
    "name": "mz_zip_reader_extract_to_callback",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nmz_bool mz_zip_reader_extract_to_callback(mz_zip_archive *pZip, mz_uint file_index, mz_file_write_func pCallback, void *pOpaque, mz_uint flags);\nmz_bool mz_zip_reader_extract_file_to_callback(mz_zip_archive *pZip, const char *pFilename, mz_file_write_func pCallback, void *pOpaque, mz_uint flags);\n```\n>  Extracts a archive file using a callback function to output the file's data. \n",
    "lang": "c"
  },
  {
    "name": "mz_zip_reader_extract_iter_new",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nmz_zip_reader_extract_iter_state* mz_zip_reader_extract_iter_new(mz_zip_archive *pZip, mz_uint file_index, mz_uint flags);\nmz_zip_reader_extract_iter_state* mz_zip_reader_extract_file_iter_new(mz_zip_archive *pZip, const char *pFilename, mz_uint flags);\nsize_t mz_zip_reader_extract_iter_read(mz_zip_reader_extract_iter_state* pState, void* pvBuf, size_t buf_size);\nmz_bool mz_zip_reader_extract_iter_free(mz_zip_reader_extract_iter_state* pState);\n```\n>  Extract a file iteratively \n",
    "lang": "c"
  },
  {
    "name": "mz_zip_reader_extract_to_file",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nmz_bool mz_zip_reader_extract_to_file(mz_zip_archive *pZip, mz_uint file_index, const char *pDst_filename, mz_uint flags);\nmz_bool mz_zip_reader_extract_file_to_file(mz_zip_archive *pZip, const char *pArchive_filename, const char *pDst_filename, mz_uint flags);\n```\n>  This function only extracts files, not archive directory records. \n",
    "lang": "c"
  },
  {
    "name": "mz_zip_reader_extract_to_cfile",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nmz_bool mz_zip_reader_extract_to_cfile(mz_zip_archive *pZip, mz_uint file_index, MZ_FILE *File, mz_uint flags);\nmz_bool mz_zip_reader_extract_file_to_cfile(mz_zip_archive *pZip, const char *pArchive_filename, MZ_FILE *pFile, mz_uint flags);\n#endif\n```\n>  Extracts a archive file starting at the current position in the destination FILE stream. \n",
    "lang": "c"
  },
  {
    "name": "mz_zip_validate_file",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nmz_bool mz_zip_validate_file(mz_zip_archive *pZip, mz_uint file_index, mz_uint flags);\n```\n>  It also validates that each file can be successfully uncompressed unless the MZ_ZIP_FLAG_VALIDATE_HEADERS_ONLY is specified. \n",
    "lang": "c"
  },
  {
    "name": "mz_zip_validate_archive",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nmz_bool mz_zip_validate_archive(mz_zip_archive *pZip, mz_uint flags);\n```\n>  Validates an entire archive by calling mz_zip_validate_file() on each file. \n",
    "lang": "c"
  },
  {
    "name": "mz_zip_validate_mem_archive",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nmz_bool mz_zip_validate_mem_archive(const void *pMem, size_t size, mz_uint flags, mz_zip_error *pErr);\nmz_bool mz_zip_validate_file_archive(const char *pFilename, mz_uint flags, mz_zip_error *pErr);\n```\n>  Misc utils/helpers, valid for ZIP reading or writing \n",
    "lang": "c"
  },
  {
    "name": "mz_zip_end",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nmz_bool mz_zip_end(mz_zip_archive *pZip);\n```\n>  Universal end function - calls either mz_zip_reader_end() or mz_zip_writer_end(). \n",
    "lang": "c"
  },
  {
    "name": "mz_zip_writer_init",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nmz_bool mz_zip_writer_init(mz_zip_archive *pZip, mz_uint64 existing_size);\nmz_bool mz_zip_writer_init_v2(mz_zip_archive *pZip, mz_uint64 existing_size, mz_uint flags);\n```\n> The output is streamable, i.e. file_ofs in mz_file_write_func always increases only by n\n",
    "lang": "c"
  },
  {
    "name": "mz_zip_writer_init_from_reader",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nmz_bool mz_zip_writer_init_from_reader(mz_zip_archive *pZip, const char *pFilename);\nmz_bool mz_zip_writer_init_from_reader_v2(mz_zip_archive *pZip, const char *pFilename, mz_uint flags);\n```\n>  the archive is finalized the file's central directory will be hosed. \n",
    "lang": "c"
  },
  {
    "name": "mz_zip_writer_add_mem",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nmz_bool mz_zip_writer_add_mem(mz_zip_archive *pZip, const char *pArchive_name, const void *pBuf, size_t buf_size, mz_uint level_and_flags);\n```\n>  level_and_flags - compression level (0-10, see MZ_BEST_SPEED, MZ_BEST_COMPRESSION, etc.) logically OR'd with zero or more mz_zip_flags, or just set to MZ_DEFAULT_COMPRESSION. \n",
    "lang": "c"
  },
  {
    "name": "mz_zip_writer_add_mem_ex",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nmz_bool mz_zip_writer_add_mem_ex(mz_zip_archive *pZip, const char *pArchive_name, const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags,\n                                 mz_uint64 uncomp_size, mz_uint32 uncomp_crc32);\n```\n>  uncomp_size/uncomp_crc32 are only used if the MZ_ZIP_FLAG_COMPRESSED_DATA flag is specified. \n",
    "lang": "c"
  },
  {
    "name": "mz_zip_writer_add_file",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nmz_bool mz_zip_writer_add_file(mz_zip_archive *pZip, const char *pArchive_name, const char *pSrc_filename, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags);\n```\n>  level_and_flags - compression level (0-10, see MZ_BEST_SPEED, MZ_BEST_COMPRESSION, etc.) logically OR'd with zero or more mz_zip_flags, or just set to MZ_DEFAULT_COMPRESSION. \n",
    "lang": "c"
  },
  {
    "name": "mz_zip_writer_add_cfile",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nmz_bool mz_zip_writer_add_cfile(mz_zip_archive *pZip, const char *pArchive_name, MZ_FILE *pSrc_file, mz_uint64 size_to_add,\n                                const MZ_TIME_T *pFile_time, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags, const char *user_extra_data_local, mz_uint user_extra_data_local_len,\n                                const char *user_extra_data_central, mz_uint user_extra_data_central_len);\n#endif\n```\n>  Like mz_zip_writer_add_file(), except the file data is read from the specified FILE stream. \n",
    "lang": "c"
  },
  {
    "name": "mz_zip_writer_add_from_zip_reader",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nmz_bool mz_zip_writer_add_from_zip_reader(mz_zip_archive *pZip, mz_zip_archive *pSource_zip, mz_uint src_file_index);\n```\n>  This function fully clones the source file's compressed data (no recompression), along with its full filename, extra data (it may add or modify the zip64 local header extra data field), and the optional descriptor following the compressed data. \n",
    "lang": "c"
  },
  {
    "name": "mz_zip_writer_finalize_archive",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nmz_bool mz_zip_writer_finalize_archive(mz_zip_archive *pZip);\n```\n>  An archive must be manually finalized by calling this function for it to be valid. \n",
    "lang": "c"
  },
  {
    "name": "mz_zip_writer_finalize_heap_archive",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nmz_bool mz_zip_writer_finalize_heap_archive(mz_zip_archive *pZip, void **ppBuf, size_t *pSize);\n```\n>  The heap block will be allocated using the mz_zip_archive's alloc/realloc callbacks. \n",
    "lang": "c"
  },
  {
    "name": "mz_zip_writer_end",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nmz_bool mz_zip_writer_end(mz_zip_archive *pZip);\n```\n>  Note for the archive to be valid, it *must* have been finalized before ending (this function will not do it for you). \n",
    "lang": "c"
  },
  {
    "name": "mz_zip_add_mem_to_archive_file_in_place",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nmz_bool mz_zip_add_mem_to_archive_file_in_place(const char *pZip_filename, const char *pArchive_name, const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags);\nmz_bool mz_zip_add_mem_to_archive_file_in_place_v2(const char *pZip_filename, const char *pArchive_name, const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags, mz_zip_error *pErr);\n```\n>  TODO: Perhaps add an option to leave the existing central dir in place in case the add dies? We could then truncate the file (so the old central dir would be at the end) if something goes wrong. \n",
    "lang": "c"
  },
  {
    "name": "mz_zip_extract_archive_file_to_heap",
    "file": "[miniz.h](https://github.com/mongoose-os-libs/miniz/blob/master/include/miniz.h)",
    "doc": "\n```c\nvoid *mz_zip_extract_archive_file_to_heap(const char *pZip_filename, const char *pArchive_name, size_t *pSize, mz_uint flags);\nvoid *mz_zip_extract_archive_file_to_heap_v2(const char *pZip_filename, const char *pArchive_name, const char *pComment, size_t *pSize, mz_uint flags, mz_zip_error *pErr);\n```\n>  Returns NULL on failure. \n",
    "lang": "c"
  },
  {
    "name": "mgos_mjs_get_global",
    "file": "[mos_mjs.h](https://github.com/mongoose-os-libs/mjs/blob/master/include/mos_mjs.h)",
    "doc": "\n```c\nstruct mjs *mgos_mjs_get_global(void);\n```\n>  Return global mJS instance. \n",
    "lang": "c"
  },
  {
    "name": "mgos_get_mgr",
    "file": "[mgos_mongoose.h](https://github.com/mongoose-os-libs/mongoose/blob/master/include/mgos_mongoose.h)",
    "doc": "\n```c\nstruct mg_mgr *mgos_get_mgr(void);\n```\n>  Return global event manager \n",
    "lang": "c"
  },
  {
    "name": "mongoose_poll",
    "file": "[mgos_mongoose.h](https://github.com/mongoose-os-libs/mongoose/blob/master/include/mgos_mongoose.h)",
    "doc": "\n```c\nint mongoose_poll(int ms);\n```\n> \n> If there are active connections, calls `mg_mgr_poll` on global event\n> manager. Also calls all registered on-poll callbacks (see\n> `mgos_add_poll_cb()` and friends). Also feeds watchdog if that feature is\n> enabled (see `mgos_wdt_set_feed_on_poll()`). Also reports min free heap size\n> if that feature is enabled (see `mgos_set_enable_min_heap_free_reporting()`)\n>  \n",
    "lang": "c"
  },
  {
    "name": "(*mgos_poll_cb_t)",
    "file": "[mgos_mongoose.h](https://github.com/mongoose-os-libs/mongoose/blob/master/include/mgos_mongoose.h)",
    "doc": "\n```c\ntypedef void (*mgos_poll_cb_t)(void *cb_arg);\n```\n> \n> On-poll callback; `cb_arg` is an arbitrary pointer given to\n> `mgos_add_poll_cb()`\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_add_poll_cb",
    "file": "[mgos_mongoose.h](https://github.com/mongoose-os-libs/mongoose/blob/master/include/mgos_mongoose.h)",
    "doc": "\n```c\nvoid mgos_add_poll_cb(mgos_poll_cb_t cb, void *cb_arg);\n```\n> \n> Add an on-poll callback with an arbitrary argument, see `mongoose_poll()`.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_remove_poll_cb",
    "file": "[mgos_mongoose.h](https://github.com/mongoose-os-libs/mongoose/blob/master/include/mgos_mongoose.h)",
    "doc": "\n```c\nvoid mgos_remove_poll_cb(mgos_poll_cb_t cb, void *cb_arg);\n```\n> \n> Remove an on-poll callback, see `mongoose_poll()`.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_wdt_set_feed_on_poll",
    "file": "[mgos_mongoose.h](https://github.com/mongoose-os-libs/mongoose/blob/master/include/mgos_mongoose.h)",
    "doc": "\n```c\nvoid mgos_wdt_set_feed_on_poll(bool enable);\n```\n> \n> Set whether wdt should be fed on each call to `mongoose_poll()`.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_set_enable_min_heap_free_reporting",
    "file": "[mgos_mongoose.h](https://github.com/mongoose-os-libs/mongoose/blob/master/include/mgos_mongoose.h)",
    "doc": "\n```c\nvoid mgos_set_enable_min_heap_free_reporting(bool enable);\n```\n> \n> Set whether min free heap size should be reported on each call to\n> `mongoose_poll()`.\n>  \n",
    "lang": "c"
  },
  {
    "name": "MQ135.attach(pin)",
    "file": "[api_mq135.js](https://github.com/mongoose-os-libs/mq135/blob/master/mjs_fs/api_mq135.js)",
    "doc": "\n```javascript\nMQ135.attach(pin)\n```\nAttach to a given pin.\n",
    "lang": "js"
  },
  {
    "name": "MQ135.getResistance()",
    "file": "[api_mq135.js](https://github.com/mongoose-os-libs/mq135/blob/master/mjs_fs/api_mq135.js)",
    "doc": "\n```javascript\nMQ135.getResistance()\n```\nGet the resistance of the sensor, ie. the measurement value.\nReturn sensor resistance in kOhm\n",
    "lang": "js"
  },
  {
    "name": "MQ135.getPPM(pin)",
    "file": "[api_mq135.js](https://github.com/mongoose-os-libs/mq135/blob/master/mjs_fs/api_mq135.js)",
    "doc": "\n```javascript\nMQ135.getPPM(pin)\n```\nGet the ppm of CO2 sensed (assuming only CO2 in the air). Return the ppm of CO2 in the air\n",
    "lang": "js"
  },
  {
    "name": "MQ135.getRZero()",
    "file": "[api_mq135.js](https://github.com/mongoose-os-libs/mq135/blob/master/mjs_fs/api_mq135.js)",
    "doc": "\n```javascript\nMQ135.getRZero()\n```\nGet the resistance RZero of the sensor for calibration purposes.\nSet this value to your \"MQ.RZERO\" variable if you need.\n",
    "lang": "js"
  },
  {
    "name": "MQ135.getCorrectionFactor(temperature, humidity)",
    "file": "[api_mq135.js](https://github.com/mongoose-os-libs/mq135/blob/master/mjs_fs/api_mq135.js)",
    "doc": "\n```javascript\nMQ135.getCorrectionFactor(temperature, humidity)\n```\nGet the correction factor to correct for `temperature` and `humidity`.\n`temperature` is the ambient air temperature, `humidity` is the relative humidity.\nReturn the calculated correction factor.\n",
    "lang": "js"
  },
  {
    "name": "MQ135.getCorrectedResistance(temperature, humidity)",
    "file": "[api_mq135.js](https://github.com/mongoose-os-libs/mq135/blob/master/mjs_fs/api_mq135.js)",
    "doc": "\n```javascript\nMQ135.getCorrectedResistance(temperature, humidity)\n```\nGet the resistance of the sensor, ie. the measurement value corrected for temperature/humidity\n@param[in] temperature  The ambient air temperature\n@param[in] humidity  The relative humidity\n@return The corrected sensor resistance kOhm\n",
    "lang": "js"
  },
  {
    "name": "MQ135.getCorrectedPPM(temperature, humidity)",
    "file": "[api_mq135.js](https://github.com/mongoose-os-libs/mq135/blob/master/mjs_fs/api_mq135.js)",
    "doc": "\n```javascript\nMQ135.getCorrectedPPM(temperature, humidity)\n```\nGet the ppm of CO2 sensed (assuming only CO2 in the air), corrected for temperature/humidity\n@param[in] temperature  The ambient air temperature\n@param[in] humidity The relative humidity\n@return The ppm of CO2 in the air\n",
    "lang": "js"
  },
  {
    "name": "MQ135.getCorrectedRZero(temperature, humidity)",
    "file": "[api_mq135.js](https://github.com/mongoose-os-libs/mq135/blob/master/mjs_fs/api_mq135.js)",
    "doc": "\n```javascript\nMQ135.getCorrectedRZero(temperature, humidity)\n```\nGet the resistance RZero of the sensor for calibration purposes\n@param[in] temperature  The ambient air temperature\n@param[in] humidity The relative humidity\n@return The sensor resistance RZero in kOhm\n",
    "lang": "js"
  },
  {
    "name": "mgos_mqtt_global_subscribe",
    "file": "[mgos_mqtt.h](https://github.com/mongoose-os-libs/mqtt/blob/master/include/mgos_mqtt.h)",
    "doc": "\n```c\nvoid mgos_mqtt_global_subscribe(const struct mg_str topic,\n                                mg_event_handler_t handler, void *ud);\n```\n> \n> Subscribe to a specific topic.\n> This handler will receive SUBACK - when first subscribed to the topic,\n> PUBLISH - for messages published to this topic, PUBACK - acks for PUBLISH\n> requests. MG_EV_CLOSE - when connection is closed.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_mqtt_add_global_handler",
    "file": "[mgos_mqtt.h](https://github.com/mongoose-os-libs/mqtt/blob/master/include/mgos_mqtt.h)",
    "doc": "\n```c\nvoid mgos_mqtt_add_global_handler(mg_event_handler_t handler, void *ud);\n```\n>  Registers a mongoose handler to be invoked on the global MQTT connection \n",
    "lang": "c"
  },
  {
    "name": "(*mgos_mqtt_connect_fn_t)",
    "file": "[mgos_mqtt.h](https://github.com/mongoose-os-libs/mqtt/blob/master/include/mgos_mqtt.h)",
    "doc": "\n```c\ntypedef void (*mgos_mqtt_connect_fn_t)(struct mg_connection *c,\n                                       const char *client_id,\n                                       struct mg_send_mqtt_handshake_opts *opts,\n                                       void *fn_arg);\n```\n> \n> Callback signature for `mgos_mqtt_set_connect_fn()`, see its docs for\n> details.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_mqtt_set_connect_fn",
    "file": "[mgos_mqtt.h](https://github.com/mongoose-os-libs/mqtt/blob/master/include/mgos_mqtt.h)",
    "doc": "\n```c\nvoid mgos_mqtt_set_connect_fn(mgos_mqtt_connect_fn_t cb, void *fn_arg);\n```\n> \n> Set connect callback. It is invoked when CONNECT message is about to\n> be sent. The callback is responsible to call `mg_send_mqtt_handshake_opt()`\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_mqtt_get_global_conn",
    "file": "[mgos_mqtt.h](https://github.com/mongoose-os-libs/mqtt/blob/master/include/mgos_mqtt.h)",
    "doc": "\n```c\nstruct mg_connection *mgos_mqtt_get_global_conn(void);\n```\n> \n> Returns current MQTT connection if it is established; otherwise returns\n> `NULL`\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_mqtt_global_connect",
    "file": "[mgos_mqtt.h](https://github.com/mongoose-os-libs/mqtt/blob/master/include/mgos_mqtt.h)",
    "doc": "\n```c\nbool mgos_mqtt_global_connect(void);\n```\n> \n> Attempt MQTT connection now (if enabled and not already connected).\n> Normally MQTT will try to connect in the background, at certain interval.\n> This function will force immediate connection attempt.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_mqtt_global_disconnect",
    "file": "[mgos_mqtt.h](https://github.com/mongoose-os-libs/mqtt/blob/master/include/mgos_mqtt.h)",
    "doc": "\n```c\nvoid mgos_mqtt_global_disconnect(void);\n```\n> \n> Disconnect from and/or stop trying to connect to MQTT server\n> until mgos_mqtt_global_connect() is called.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_mqtt_global_is_connected",
    "file": "[mgos_mqtt.h](https://github.com/mongoose-os-libs/mqtt/blob/master/include/mgos_mqtt.h)",
    "doc": "\n```c\nbool mgos_mqtt_global_is_connected(void);\n```\n>  Returns true if MQTT connection is up, false otherwise. \n",
    "lang": "c"
  },
  {
    "name": "mgos_mqtt_pub",
    "file": "[mgos_mqtt.h](https://github.com/mongoose-os-libs/mqtt/blob/master/include/mgos_mqtt.h)",
    "doc": "\n```c\nuint16_t mgos_mqtt_pub(const char *topic, const void *message, size_t len,\n                       int qos, bool retain);\n```\n> \n> Publish message to the configured MQTT server, to the given MQTT topic.\n> Return value will be the packet id (> 0) if there is a connection to the\n> server and the message has been queued for sending. In case no connection is\n> available, 0 is returned. In case of QoS 1 return value does not indicate\n> that PUBACK has been received; there is currently no way to check for that.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_mqtt_pubf",
    "file": "[mgos_mqtt.h](https://github.com/mongoose-os-libs/mqtt/blob/master/include/mgos_mqtt.h)",
    "doc": "\n```c\nuint16_t mgos_mqtt_pubf(const char *topic, int qos, bool retain,\n                        const char *json_fmt, ...);\nuint16_t mgos_mqtt_pubv(const char *topic, int qos, bool retain,\n                        const char *json_fmt, va_list ap);\n```\n>  Variant of mgos_mqtt_pub for publishing a JSON-formatted string \n",
    "lang": "c"
  },
  {
    "name": "(*sub_handler_t)",
    "file": "[mgos_mqtt.h](https://github.com/mongoose-os-libs/mqtt/blob/master/include/mgos_mqtt.h)",
    "doc": "\n```c\ntypedef void (*sub_handler_t)(struct mg_connection *nc, const char *topic,\n                              int topic_len, const char *msg, int msg_len,\n                              void *ud);\n/*\n * Subscribe on a topic on a configured MQTT server.\n */\nvoid mgos_mqtt_sub(const char *topic, sub_handler_t, void *ud);\n```\n> \n> Callback signature for `mgos_mqtt_sub()` below.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_mqtt_num_unsent_bytes",
    "file": "[mgos_mqtt.h](https://github.com/mongoose-os-libs/mqtt/blob/master/include/mgos_mqtt.h)",
    "doc": "\n```c\nsize_t mgos_mqtt_num_unsent_bytes(void);\n```\n> \n> Returns number of pending bytes to send.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_mqtt_get_packet_id",
    "file": "[mgos_mqtt.h](https://github.com/mongoose-os-libs/mqtt/blob/master/include/mgos_mqtt.h)",
    "doc": "\n```c\nuint16_t mgos_mqtt_get_packet_id(void);\n```\n> \n> Returns next packet id; the returned value is incremented every time the\n> function is called, and it's never 0 (so after 0xffff it'll be 1)\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_mqtt_set_max_qos",
    "file": "[mgos_mqtt.h](https://github.com/mongoose-os-libs/mqtt/blob/master/include/mgos_mqtt.h)",
    "doc": "\n```c\nvoid mgos_mqtt_set_max_qos(int qos);\n```\n> \n> Set maximum QOS level that is supported by server: 0, 1 or 2.\n> Some servers, particularly AWS GreenGrass, accept only QoS0 transactions.\n> An attempt to use any other QoS results into silent disconnect.\n> Therefore, instead of forcing all client code to track such server's quirks,\n> we add mechanism to transparently downgrade the QoS.\n>  \n",
    "lang": "c"
  },
  {
    "name": "MQTT.isConnected()",
    "file": "[api_mqtt.js](https://github.com/mongoose-os-libs/mqtt/blob/master/mjs_fs/api_mqtt.js)",
    "doc": "\n```javascript\nMQTT.isConnected()\n```\nReturn value: true if MQTT connection is up, false otherwise.\n",
    "lang": "js"
  },
  {
    "name": "MQTT.sub(topic, handler)",
    "file": "[api_mqtt.js](https://github.com/mongoose-os-libs/mqtt/blob/master/mjs_fs/api_mqtt.js)",
    "doc": "\n```javascript\nMQTT.sub(topic, handler)\n```\nSubscribe to a topic, and call given handler function when message arrives.\nA handler receives 4 parameters: MQTT connection, topic name,\nmessage, and userdata.\nReturn value: none.\n\nExample:\n```javascript\nload('api_mqtt.js');\nMQTT.sub('my/topic/#', function(conn, topic, msg) {\n  print('Topic:', topic, 'message:', msg);\n}, null);\n```\n",
    "lang": "js"
  },
  {
    "name": "MQTT.pub(topic, message, qos, retain)",
    "file": "[api_mqtt.js](https://github.com/mongoose-os-libs/mqtt/blob/master/mjs_fs/api_mqtt.js)",
    "doc": "\n```javascript\nMQTT.pub(topic, message, qos, retain)\n```\nPublish message to a topic. If `qos` is not specified, it defaults to 0.\nIf `retain` is not specified, it defaults to `false`.\nReturn value: 0 on failure (e.g. no connection to server), 1 on success.\n\nExample - send MQTT message on button press, with QoS 1, no retain:\n```javascript\nload('api_mqtt.js');\nload('api_gpio.js');\nlet pin = 0, topic = 'my/topic';\nGPIO.set_button_handler(pin, GPIO.PULL_UP, GPIO.INT_EDGE_NEG, 200, function() {\n  let res = MQTT.pub('my/topic', JSON.stringify({ a: 1, b: 2 }), 1);\n  print('Published:', res ? 'yes' : 'no');\n}, null);\n```\n",
    "lang": "js"
  },
  {
    "name": "MQTT.setEventHandler(handler, userdata)",
    "file": "[api_mqtt.js](https://github.com/mongoose-os-libs/mqtt/blob/master/mjs_fs/api_mqtt.js)",
    "doc": "\n```javascript\nMQTT.setEventHandler(handler, userdata)\n```\nSet MQTT connection event handler. Event handler is\n`ev_handler(conn, ev, edata)`, where `conn` is an opaque connection handle,\n`ev` is an event number, `edata` is an event-specific data.\n`ev` values could be low-level network events, like `Net.EV_CLOSE`\nor `Net.EV_POLL`, or MQTT specific events, like `MQTT.EV_CONNACK`.\n\nExample:\n```javascript\nMQTT.setEventHandler(function(conn, ev, edata) {\n  if (ev !== 0) print('MQTT event handler: got', ev);\n}, null);\n```\n",
    "lang": "js"
  },
  {
    "name": "mgos_neopixel_create",
    "file": "[mgos_neopixel.h](https://github.com/mongoose-os-libs/neopixel/blob/master/include/mgos_neopixel.h)",
    "doc": "\n```c\nstruct mgos_neopixel *mgos_neopixel_create(int pin, int num_pixels,\n                                           enum mgos_neopixel_order order);\n```\n> \n> Create and return a NeoPixel strip object. Example:\n> ```c\n> struct mgos_neopixel *mystrip = mgos_neopixel_create(\n>     5, 16, MGOS_NEOPIXEL_ORDER_GRB);\n> mgos_neopixel_set(mystrip, 0, 12, 34, 56);\n> mgos_neopixel_show(mystrip);\n> \n> mgos_neopixel_clear(mystrip);\n> mgos_neopixel_set(mystrip, 1, 12, 34, 56);\n> mgos_neopixel_show(mystrip);\n> ```\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_neopixel_set",
    "file": "[mgos_neopixel.h](https://github.com/mongoose-os-libs/neopixel/blob/master/include/mgos_neopixel.h)",
    "doc": "\n```c\nvoid mgos_neopixel_set(struct mgos_neopixel *np, int i, int r, int g, int b);\n```\n> \n> Set i-th pixel's RGB value. Each color (`r`, `g`, `b`) should be an integer\n> from 0 to 255; they are ints and not `uint8_t`s just for the FFI.\n> \n> Note that this only affects in-memory value of the pixel; you'll need to\n> call `mgos_neopixel_show()` to apply changes.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_neopixel_clear",
    "file": "[mgos_neopixel.h](https://github.com/mongoose-os-libs/neopixel/blob/master/include/mgos_neopixel.h)",
    "doc": "\n```c\nvoid mgos_neopixel_clear(struct mgos_neopixel *np);\n```\n> \n> Clear in-memory values of the pixels.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_neopixel_show",
    "file": "[mgos_neopixel.h](https://github.com/mongoose-os-libs/neopixel/blob/master/include/mgos_neopixel.h)",
    "doc": "\n```c\nvoid mgos_neopixel_show(struct mgos_neopixel *np);\n```\n> \n> Output values of the pixels.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_neopixel_free",
    "file": "[mgos_neopixel.h](https://github.com/mongoose-os-libs/neopixel/blob/master/include/mgos_neopixel.h)",
    "doc": "\n```c\nvoid mgos_neopixel_free(struct mgos_neopixel *np);\n```\n> \n> Free neopixel instance.\n>  \n",
    "lang": "c"
  },
  {
    "name": "NeoPixel.create(pin, numPixels, order)",
    "file": "[api_neopixel.js](https://github.com/mongoose-os-libs/neopixel/blob/master/mjs_fs/api_neopixel.js)",
    "doc": "\n```javascript\nNeoPixel.create(pin, numPixels, order)\n```\nCreate and return a NeoPixel strip object. Example:\n```javascript\nlet pin = 5, numPixels = 16, colorOrder = NeoPixel.GRB;\nlet strip = NeoPixel.create(pin, numPixels, colorOrder);\nstrip.setPixel(0 /* pixel */, 12, 34, 56);\nstrip.show();\n\nstrip.clear();\nstrip.setPixel(1 /* pixel */, 12, 34, 56);\nstrip.show();\n```\n",
    "lang": "js"
  },
  {
    "name": "strip.setPixel(i, r, g, b)",
    "file": "[api_neopixel.js](https://github.com/mongoose-os-libs/neopixel/blob/master/mjs_fs/api_neopixel.js)",
    "doc": "\n```javascript\nstrip.setPixel(i, r, g, b)\n```\nSet i-th's pixel's RGB value.\nNote that this only affects in-memory value of the pixel.\n",
    "lang": "js"
  },
  {
    "name": "strip.clear()",
    "file": "[api_neopixel.js](https://github.com/mongoose-os-libs/neopixel/blob/master/mjs_fs/api_neopixel.js)",
    "doc": "\n```javascript\nstrip.clear()\n```\nClear in-memory values of the pixels.\n",
    "lang": "js"
  },
  {
    "name": "strip.show()",
    "file": "[api_neopixel.js](https://github.com/mongoose-os-libs/neopixel/blob/master/mjs_fs/api_neopixel.js)",
    "doc": "\n```javascript\nstrip.show()\n```\nOutput values of the pixels.\n",
    "lang": "js"
  },
  {
    "name": "mgos_onewire_crc8",
    "file": "[mgos_onewire.h](https://github.com/mongoose-os-libs/onewire/blob/master/include/mgos_onewire.h)",
    "doc": "\n```c\nuint8_t mgos_onewire_crc8(const uint8_t *rom, int len);\n```\n> \n> Calculate CRC8 of the given chunk of memory.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_onewire_create",
    "file": "[mgos_onewire.h](https://github.com/mongoose-os-libs/onewire/blob/master/include/mgos_onewire.h)",
    "doc": "\n```c\nstruct mgos_onewire *mgos_onewire_create(int pin);\n```\n> \n> Create onewire instance on a given pin.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_onewire_reset",
    "file": "[mgos_onewire.h](https://github.com/mongoose-os-libs/onewire/blob/master/include/mgos_onewire.h)",
    "doc": "\n```c\nbool mgos_onewire_reset(struct mgos_onewire *ow);\n```\n> \n> Reset onewire bus. Usually this is needed before communicating with any\n> device.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_onewire_target_setup",
    "file": "[mgos_onewire.h](https://github.com/mongoose-os-libs/onewire/blob/master/include/mgos_onewire.h)",
    "doc": "\n```c\nvoid mgos_onewire_target_setup(struct mgos_onewire *ow,\n                               const uint8_t family_code);\n/*\n * Search for the next device. The given `rom` should point to a chunk of at\n * least 8 bytes; result will be written there. `mode` is as follows:\n * 0 - normal search, 1 - conditional search.\n */\nbool mgos_onewire_next(struct mgos_onewire *ow, uint8_t *rom, int mode);\n```\n> \n> Setup the search to find the device type 'family_code' on the next call\n> mgos_onewire_next() if it is present Note if no devices of the desired\n> family are currently on the 1-Wire, then another type will be found.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_onewire_select",
    "file": "[mgos_onewire.h](https://github.com/mongoose-os-libs/onewire/blob/master/include/mgos_onewire.h)",
    "doc": "\n```c\nvoid mgos_onewire_select(struct mgos_onewire *ow, const uint8_t *rom);\n```\n> \n> Select a device based on is address `rom`, which is a 8-byte string. After\n> a reset, this is needed to choose which device you will use, and then all\n> communication will be with that device, until another reset.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_onewire_skip",
    "file": "[mgos_onewire.h](https://github.com/mongoose-os-libs/onewire/blob/master/include/mgos_onewire.h)",
    "doc": "\n```c\nvoid mgos_onewire_skip(struct mgos_onewire *ow);\n```\n> \n> Skip the device selection. This only works if you have a single device, but\n> you can avoid searching and use this to immediately access your device.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_onewire_search_clean",
    "file": "[mgos_onewire.h](https://github.com/mongoose-os-libs/onewire/blob/master/include/mgos_onewire.h)",
    "doc": "\n```c\nvoid mgos_onewire_search_clean(struct mgos_onewire *ow);\n```\n> \n> Reset a search. Next use of `mgos_onewire_next` will begin at the first\n> device.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_onewire_read_bit",
    "file": "[mgos_onewire.h](https://github.com/mongoose-os-libs/onewire/blob/master/include/mgos_onewire.h)",
    "doc": "\n```c\nbool mgos_onewire_read_bit(struct mgos_onewire *ow);\n```\n> \n> Read a single bit from the onewire bus. Returned value is `true` for 1, or\n> `false` for 0.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_onewire_read",
    "file": "[mgos_onewire.h](https://github.com/mongoose-os-libs/onewire/blob/master/include/mgos_onewire.h)",
    "doc": "\n```c\nuint8_t mgos_onewire_read(struct mgos_onewire *ow);\n```\n> \n> Read a byte from the onewire bus.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_onewire_read_bytes",
    "file": "[mgos_onewire.h](https://github.com/mongoose-os-libs/onewire/blob/master/include/mgos_onewire.h)",
    "doc": "\n```c\nvoid mgos_onewire_read_bytes(struct mgos_onewire *ow, uint8_t *buf, int len);\n```\n> \n> Read `len` bytes from the onewire bus to the buffer `buf`.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_onewire_write_bit",
    "file": "[mgos_onewire.h](https://github.com/mongoose-os-libs/onewire/blob/master/include/mgos_onewire.h)",
    "doc": "\n```c\nvoid mgos_onewire_write_bit(struct mgos_onewire *ow, int bit);\n```\n> \n> Write a single bit to the onewire bus; given `bit` should be either `0` or\n> `1`.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_onewire_write",
    "file": "[mgos_onewire.h](https://github.com/mongoose-os-libs/onewire/blob/master/include/mgos_onewire.h)",
    "doc": "\n```c\nvoid mgos_onewire_write(struct mgos_onewire *ow, const uint8_t data);\n```\n> \n> Write a byte to the onewire bus.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_onewire_write_bytes",
    "file": "[mgos_onewire.h](https://github.com/mongoose-os-libs/onewire/blob/master/include/mgos_onewire.h)",
    "doc": "\n```c\nvoid mgos_onewire_write_bytes(struct mgos_onewire *ow, const uint8_t *buf,\n                              int len);\n```\n> \n> Write `len` bytes to the onewire bus from `buf`.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_onewire_close",
    "file": "[mgos_onewire.h](https://github.com/mongoose-os-libs/onewire/blob/master/include/mgos_onewire.h)",
    "doc": "\n```c\nvoid mgos_onewire_close(struct mgos_onewire *ow);\n```\n> \n> Close onewire instance and free the occupied memory.\n>  \n",
    "lang": "c"
  },
  {
    "name": "reset",
    "file": "[OnewireRmt.h](https://github.com/mongoose-os-libs/onewire-rmt/blob/master/include/OnewireRmt.h)",
    "doc": "\n```c\nuint8_t reset(void);\n```\n> \n> Perform a 1-Wire reset cycle. Returns 1 if a device responds\n> with a presence pulse.  Returns 0 if there is no device or the\n> bus is shorted or otherwise held low for more than 250uS\n>      \n",
    "lang": "c"
  },
  {
    "name": "select",
    "file": "[OnewireRmt.h](https://github.com/mongoose-os-libs/onewire-rmt/blob/master/include/OnewireRmt.h)",
    "doc": "\n```c\nvoid select(const uint8_t rom[8]);\n```\n> \n> Issues a 1-Wire rom select command, you do the reset first.\n>      \n",
    "lang": "c"
  },
  {
    "name": "skip",
    "file": "[OnewireRmt.h](https://github.com/mongoose-os-libs/onewire-rmt/blob/master/include/OnewireRmt.h)",
    "doc": "\n```c\nvoid skip(void);\n```\n> \n> Issues a 1-Wire rom skip command, to address all on bus.\n>      \n",
    "lang": "c"
  },
  {
    "name": "write",
    "file": "[OnewireRmt.h](https://github.com/mongoose-os-libs/onewire-rmt/blob/master/include/OnewireRmt.h)",
    "doc": "\n```c\nvoid write(uint8_t v, uint8_t power = 0);\n    void write_bytes(const uint8_t *buf, uint16_t count, bool power = 0);\n```\n> \n> Write a byte/sequence of bytes. If 'power' is one then the wire is held high at\n> the end for parasitically powered devices. You are responsible\n> for eventually depowering it by calling depower() or doing\n> another read or write.\n>      \n",
    "lang": "c"
  },
  {
    "name": "read",
    "file": "[OnewireRmt.h](https://github.com/mongoose-os-libs/onewire-rmt/blob/master/include/OnewireRmt.h)",
    "doc": "\n```c\nuint8_t read(void);\n    void read_bytes(uint8_t *buf, uint16_t count);\n```\n> \n> Read a byte/sequence of bytes.\n>      \n",
    "lang": "c"
  },
  {
    "name": "write_bit",
    "file": "[OnewireRmt.h](https://github.com/mongoose-os-libs/onewire-rmt/blob/master/include/OnewireRmt.h)",
    "doc": "\n```c\nvoid write_bit(uint8_t v);\n```\n> \n> Write a bit. The bus is always left powered at the end, see\n> note in write() about that.\n>      \n",
    "lang": "c"
  },
  {
    "name": "read_bit",
    "file": "[OnewireRmt.h](https://github.com/mongoose-os-libs/onewire-rmt/blob/master/include/OnewireRmt.h)",
    "doc": "\n```c\nuint8_t read_bit(void);\n```\n> \n> Read a bit.\n>      \n",
    "lang": "c"
  },
  {
    "name": "depower",
    "file": "[OnewireRmt.h](https://github.com/mongoose-os-libs/onewire-rmt/blob/master/include/OnewireRmt.h)",
    "doc": "\n```c\nvoid depower(void);\n```\n> \n> Stop forcing power onto the bus. You only need to do this if\n> you used the 'power' flag to write() or used a write_bit() call\n> and aren't about to do another read or write. You would rather\n> not leave this powered if you don't have to, just in case\n> someone shorts your bus.\n>      \n",
    "lang": "c"
  },
  {
    "name": "reset_search",
    "file": "[OnewireRmt.h](https://github.com/mongoose-os-libs/onewire-rmt/blob/master/include/OnewireRmt.h)",
    "doc": "\n```c\nvoid reset_search();\n```\n> \n> Clear the search state so that if will start from the beginning again.\n>      \n",
    "lang": "c"
  },
  {
    "name": "target_search",
    "file": "[OnewireRmt.h](https://github.com/mongoose-os-libs/onewire-rmt/blob/master/include/OnewireRmt.h)",
    "doc": "\n```c\nvoid target_search(uint8_t family_code);\n```\n> \n> Setup the search to find the device type 'family_code' on the next call\n> to search(*newAddr) if it is present.\n>      \n",
    "lang": "c"
  },
  {
    "name": "search",
    "file": "[OnewireRmt.h](https://github.com/mongoose-os-libs/onewire-rmt/blob/master/include/OnewireRmt.h)",
    "doc": "\n```c\nuint8_t search(uint8_t *newAddr, bool search_mode = true);\n```\n> \n> Look for the next device. Returns 1 if a new address has been\n> returned. A zero might mean that the bus is shorted, there are\n> no devices, or you have already retrieved all of them.  It\n> might be a good idea to check the CRC to make sure you didn't\n> get garbage.  The order is deterministic. You will always get\n> the same devices in the same order.\n>      \n",
    "lang": "c"
  },
  {
    "name": "crc8",
    "file": "[OnewireRmt.h](https://github.com/mongoose-os-libs/onewire-rmt/blob/master/include/OnewireRmt.h)",
    "doc": "\n```c\nstatic uint8_t crc8(const uint8_t *addr, uint8_t len);\n```\n> \n> Compute a Dallas Semiconductor 8 bit CRC, these are used in the\n> ROM and scratchpad registers.\n>      \n",
    "lang": "c"
  },
  {
    "name": "mgos_ota_http_start",
    "file": "[mgos_ota_http_client.h](https://github.com/mongoose-os-libs/ota-http-client/blob/master/include/mgos_ota_http_client.h)",
    "doc": "\n```c\nvoid mgos_ota_http_start(const char *url, const struct mgos_ota_opts *opts);\n```\n>  Start OTA update by pulling the firmware from the given URL. \n",
    "lang": "c"
  },
  {
    "name": "OTA.evdataOtaStatusMsg(evdata)",
    "file": "[api_ota.js](https://github.com/mongoose-os-libs/ota-http-client/blob/master/mjs_fs/api_ota.js)",
    "doc": "\n```javascript\nOTA.evdataOtaStatusMsg(evdata)\n```\nGetter function for the `evdata` given to the event callback for the event\n`Event.OTA_STATUS`, see `Event.addHandler()` in `api_events.js`.\n",
    "lang": "js"
  },
  {
    "name": "mgos_pcf8574_create",
    "file": "[mgos_pcf857x.h](https://github.com/mongoose-os-libs/pcf857x-i2c/blob/master/include/mgos_pcf857x.h)",
    "doc": "\n```c\nstruct mgos_pcf857x *mgos_pcf8574_create(struct mgos_i2c *i2c, uint8_t i2caddr, int int_gpio);\nstruct mgos_pcf857x *mgos_pcf8575_create(struct mgos_i2c *i2c, uint8_t i2caddr, int int_gpio);\n```\n> \n> Initialize a PCF857X on the I2C bus `i2c` at address specified in `i2caddr`\n> parameter (default PCF857X is on address 0x20). The device will be polled for\n> validity, upon success a new `struct mgos_pcf857x` is allocated and\n> returned. If the device could not be found, NULL is returned.\n> To install an interrupt handler for the chip, set int_gpio to any valid GPIO\n> pin. Set it to -1 to disable interrupts.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_pcf857x_destroy",
    "file": "[mgos_pcf857x.h](https://github.com/mongoose-os-libs/pcf857x-i2c/blob/master/include/mgos_pcf857x.h)",
    "doc": "\n```c\nbool mgos_pcf857x_destroy(struct mgos_pcf857x **dev);\n```\n> \n> Destroy the data structure associated with a PCF857X device. The reference\n> to the pointer of the `struct mgos_pcf857x` has to be provided, and upon\n> successful destruction, its associated memory will be freed and the pointer\n> set to NULL and true will be returned.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_pcf857x_print_state",
    "file": "[mgos_pcf857x.h](https://github.com/mongoose-os-libs/pcf857x-i2c/blob/master/include/mgos_pcf857x.h)",
    "doc": "\n```c\nvoid mgos_pcf857x_print_state(struct mgos_pcf857x *dev);\n```\n>  Emit a logline with the pin and io register stat\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_pcf857x_gpio_set_mode",
    "file": "[mgos_pcf857x.h](https://github.com/mongoose-os-libs/pcf857x-i2c/blob/master/include/mgos_pcf857x.h)",
    "doc": "\n```c\nbool mgos_pcf857x_gpio_set_mode(struct mgos_pcf857x *dev, int pin, enum mgos_gpio_mode mode);\nbool mgos_pcf857x_gpio_setup_output(struct mgos_pcf857x *dev, int pin, bool level);\nbool mgos_pcf857x_gpio_setup_input(struct mgos_pcf857x *dev, int pin, enum mgos_gpio_pull_type pull_type);\nbool mgos_pcf857x_gpio_read(struct mgos_pcf857x *dev, int pin);\nvoid mgos_pcf857x_gpio_write(struct mgos_pcf857x *dev, int pin, bool level);\nbool mgos_pcf857x_gpio_toggle(struct mgos_pcf857x *dev, int pin);\n```\n>  These follow `mgos_gpio.h` definitions. \n",
    "lang": "c"
  },
  {
    "name": "mgos_pppos_dev_get_ip_info",
    "file": "[mgos_pppos.h](https://github.com/mongoose-os-libs/pppos/blob/master/include/mgos_pppos.h)",
    "doc": "\n```c\nbool mgos_pppos_dev_get_ip_info(int if_instance,\n                                struct mgos_net_ip_info *ip_info);\n```\n> \n> Retrieve IP configuration of the provided instance number (which should be\n> of type `MGOS_NET_IF_TYPE_PPP`), and fill provided `ip_info` with it. Returns\n> `true` in case of success, false otherwise.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_pppos_create",
    "file": "[mgos_pppos.h](https://github.com/mongoose-os-libs/pppos/blob/master/include/mgos_pppos.h)",
    "doc": "\n```c\nbool mgos_pppos_create(const struct mgos_config_pppos *cfg, int if_instance);\n```\n>  Create PPPoS interface instance.\n> cfg must remain valid for the lifetime of the instance. \n",
    "lang": "c"
  },
  {
    "name": "mgos_pppos_connect",
    "file": "[mgos_pppos.h](https://github.com/mongoose-os-libs/pppos/blob/master/include/mgos_pppos.h)",
    "doc": "\n```c\nbool mgos_pppos_connect(int if_instance);\n```\n>  Initiate connection. \n",
    "lang": "c"
  },
  {
    "name": "mgos_pppos_disconnect",
    "file": "[mgos_pppos.h](https://github.com/mongoose-os-libs/pppos/blob/master/include/mgos_pppos.h)",
    "doc": "\n```c\nbool mgos_pppos_disconnect(int if_instance);\n```\n>  Disconnect interface. \n",
    "lang": "c"
  },
  {
    "name": "(*mgos_pppos_cmd_cb_t)",
    "file": "[mgos_pppos.h](https://github.com/mongoose-os-libs/pppos/blob/master/include/mgos_pppos.h)",
    "doc": "\n```c\ntypedef bool (*mgos_pppos_cmd_cb_t)(void *cb_arg, bool ok, struct mg_str data);\n```\n> \n> Command/sequence callback.\n> ok will be set to the command response status (OK = true, ERROR == false).\n> data will contain response payload - any data received from the modem\n> after the comamnd was sent and before OK/ERROR was received.\n> Return value should indicate whether sequence should continue: if callback\n> returns true, the sequence continued and next command is executed.\n> If the return value is false, the sequence is aborted, remaining commands\n> (if any) are not executed and sequence finalizer is run (if provided).\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_pppos_run_cmds",
    "file": "[mgos_pppos.h](https://github.com/mongoose-os-libs/pppos/blob/master/include/mgos_pppos.h)",
    "doc": "\n```c\nbool mgos_pppos_run_cmds(int if_instance, const struct mgos_pppos_cmd *cmds);\n```\n> \n> Send custom command sequence. This can be sent both when the interface is\n> idle as well as when connection is up. In the latter case the connectio will\n> be suspended to execute the command sequence.\n> If cb is set, it will receive command response (not including  OK/ERROR).\n> The sequence must end with an entry that has cmd set to NULL.\n> Callback on this last entry, if set, serves as a finalzier: it will be\n> invoked when the sequence ends, successfully or not (this is passed as \"ok\"\n> argument). The finalizer does not receive and data.\n> \n> mgos_pppos_run_cmds may return false if the modem is busy executing\n> another command sequence.\n> \n> Example:\n>   // Retrieve GNSS status from SimCom GPS-capable modem:\n>   const struct mgos_pppos_cmd cmds[] = {\n>       {.cmd = \"AT+CGNSPWR=1\"},  // Turn on GNSS (if not already).\n>       {.cmd = \"AT+CGNSINF\", .cb = gnsinf_cb},\n>       {.cmd = NULL},\n>   };\n>   mgos_pppos_run_cmds(0, cmds);\n> \n>   bool gnsinf_cb(void *cb_arg, bool ok, struct mg_str data) {\n>     if (!ok) return false;\n>     int run = 0, fix = 0;\n>     char time[20];\n>     float lat = 0, lon = 0, alt = 0, speed = 0, course = 0;\n>     sscanf(data.p, \"+CGNSINF: %d,%d,%18s,%f,%f,%f,%f,%f\",\n>                    &run, &fix, time, &lat, &lon, &alt, &speed, &course);\n>     if (fix) {\n>       LOG(LL_INFO, (\"lat,lon: %f,%f alt: %.3f speed: %.2f course: %.2f\",\n>                     lat, lon, alt, speed, course));\n>     } else {\n>       LOG(LL_INFO, (\"No GNSS fix yet\"));\n>     }\n>     (void) cb_arg;\n>     return true;\n>   }\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_prometheus_metrics_printf",
    "file": "[mgos_prometheus_metrics.h](https://github.com/mongoose-os-libs/prometheus-metrics/blob/master/include/mgos_prometheus_metrics.h)",
    "doc": "\n```c\nvoid mgos_prometheus_metrics_printf(struct mg_connection *nc,\n                                    enum mgos_prometheus_metrics_type_t type,\n                                    const char *name, const char *descr,\n                                    const char *fmt, ...);\n```\n>  Output a formatted metric tuple to the network connection. For example:\n> ```c\n> uint32_t my_counter=1234;\n> mgos_prometheus_metrics_printf(nc, COUNTER, \"number_of_requests\", \"My\n> Description\",\n>                                \"%u\", my_counter);\n> ```\n> \n> will output:\n> ```\n> # TYPE number_of_requests counter\n> # HELP number_of_requests My Description\n> number_of_requests 1234\n> ```\n>  \n",
    "lang": "c"
  },
  {
    "name": "(*mgos_prometheus_metrics_fn_t)",
    "file": "[mgos_prometheus_metrics.h](https://github.com/mongoose-os-libs/prometheus-metrics/blob/master/include/mgos_prometheus_metrics.h)",
    "doc": "\n```c\ntypedef void (*mgos_prometheus_metrics_fn_t)(struct mg_connection *nc,\n                                             void *user_data);\n```\n>  Prototype of a function which is to be called on each prometheus pull/push.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_prometheus_metrics_add_handler",
    "file": "[mgos_prometheus_metrics.h](https://github.com/mongoose-os-libs/prometheus-metrics/blob/master/include/mgos_prometheus_metrics.h)",
    "doc": "\n```c\nvoid mgos_prometheus_metrics_add_handler(mgos_prometheus_metrics_fn_t handler,\n                                         void *user_data);\n```\n>  Registers a function handler, which will be called each time Prometheus\n> scrapes our HTTP /metrics endpoint. Libraries and application code can\n> register any number of handlers, which will be called one after another.\n> Example:\n> \n> ```c\n> #include \"mgos_prometheus_metrics.h\"\n> uint32_t my_counter=0;\n> \n> static void prometheus_metrics_fn(struct mg_connection *nc, void *user_data)\n> {\n>   mgos_prometheus_metrics_printf(nc, COUNTER,\n>     \"my_counter\", \"Total things counted\",\n>     \"%u\", my_counter);\n>   (void) user_data;\n> }\n> \n> enum mgos_app_init_result mgos_app_init(void) {\n>   mgos_prometheus_metrics_add_handler(prometheus_metrics_fn, NULL);\n>   return MGOS_APP_INIT_SUCCESS;\n> }\n> ```\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_prometheus_metrics_push",
    "file": "[mgos_prometheus_metrics.h](https://github.com/mongoose-os-libs/prometheus-metrics/blob/master/include/mgos_prometheus_metrics.h)",
    "doc": "\n```c\nvoid mgos_prometheus_metrics_push(const char *job, const char *instance);\n```\n>  Perform an HTTP POST request against the Prometheus Pushgateway specified in\n> the flag prometheus.pushgateway in mos.yml, using 'job' and 'instance'.\n> The job argument is mandatory, but instance can be passed NULL.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_provision_set_cur_state",
    "file": "[mgos_provision.h](https://github.com/mongoose-os-libs/provision/blob/master/include/mgos_provision.h)",
    "doc": "\n```c\nvoid mgos_provision_set_cur_state(int new_state);\n```\n>  Set new current provisioning state.\n> This will update max state if it is greater than current value, thus\n> advancing the provisioning process. \n",
    "lang": "c"
  },
  {
    "name": "mgos_provision_set_max_state",
    "file": "[mgos_provision.h](https://github.com/mongoose-os-libs/provision/blob/master/include/mgos_provision.h)",
    "doc": "\n```c\nvoid mgos_provision_set_max_state(int new_state);\n```\n>  Set new max provisioning state directly. If the target state is less than\n> the configured state, it will start the reset timer.\n> This can be used to rewind the provisioning process. \n",
    "lang": "c"
  },
  {
    "name": "mgos_provision_get_cur_state",
    "file": "[mgos_provision.h](https://github.com/mongoose-os-libs/provision/blob/master/include/mgos_provision.h)",
    "doc": "\n```c\nint mgos_provision_get_cur_state(void);\n```\n>  Get current provisioning state. \n",
    "lang": "c"
  },
  {
    "name": "mgos_provision_get_max_state",
    "file": "[mgos_provision.h](https://github.com/mongoose-os-libs/provision/blob/master/include/mgos_provision.h)",
    "doc": "\n```c\nint mgos_provision_get_max_state(void);\n```\n>  Get maximum provisioning state. \n",
    "lang": "c"
  },
  {
    "name": "mgos_pwm_set",
    "file": "[mgos_pwm.h](https://github.com/mongoose-os-libs/pwm/blob/master/include/mgos_pwm.h)",
    "doc": "\n```c\nbool mgos_pwm_set(int pin, int freq, float duty);\n```\n> \n> \n>  Set and control the PWM.\n> \n>  Params:\n>  pin:    GPIO number.\n>  freq:   Frequency, in Hz. 0 disables PWM on the pin.\n>  duty:   Specifies which fraction of the cycle is spent in \"1\" state:\n>          0 is always off, 0.5 is a square wave, 1 is always on.\n>  Return:\n>  true - SUCCESS, false - FAIL.\n> \n>  Note:\n>  On esp32 we use 8 channels and 4 timers.\n>  Each `mgos_set_pwm` call with new pin number assigns a new channel.\n>  If we already have timer running at the specified frequency,\n>  we use it instead of assigning a new one.\n>  \n",
    "lang": "c"
  },
  {
    "name": "PWM.set(pin, freq, duty)",
    "file": "[api_pwm.js](https://github.com/mongoose-os-libs/pwm/blob/master/mjs_fs/api_pwm.js)",
    "doc": "\n```javascript\nPWM.set(pin, freq, duty)\n```\nSet and control the PWM. `pin` is a GPIO pin number, `freq` is\nfrequency, in Hz. `freq` 0 disables PWM on the pin. `duty` specifies\nwhich fraction of the cycle is spent in \"1\" state: 0 is always off,\n0.5 is a square wave, 1 is always on.\nReturn: true - success, false - failure.\n\nExample:\n```javascript\nPWM.set(pin, 50, 2.73);\n```\nNote:\non ESP32 we use 8 channels and 4 timers.\nEach `PWM.set()` call with new pin number assigns a new channel.\nIf we already have a timer running at the specified frequency,\nwe use it instead of assigning a new one.\n",
    "lang": "js"
  },
  {
    "name": "mg_rpc_create",
    "file": "[mg_rpc.h](https://github.com/mongoose-os-libs/rpc-common/blob/master/include/mg_rpc.h)",
    "doc": "\n```c\nstruct mg_rpc *mg_rpc_create(struct mg_rpc_cfg *cfg);\n```\n>  Create mg_rpc instance. Takes over cfg, which must be heap-allocated. \n",
    "lang": "c"
  },
  {
    "name": "mg_rpc_add_channel",
    "file": "[mg_rpc.h](https://github.com/mongoose-os-libs/rpc-common/blob/master/include/mg_rpc.h)",
    "doc": "\n```c\nvoid mg_rpc_add_channel(struct mg_rpc *c, const struct mg_str dst,\n                        struct mg_rpc_channel *ch);\n#define MG_RPC_DST_DEFAULT \"*\"\n```\n> \n> Adds a channel to the instance.\n> If dst is empty, it will be learned when first frame arrives from the other\n> end. A \"default\" channel, if present, will be used for frames that don't have\n> a better match.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mg_rpc_remove_channel",
    "file": "[mg_rpc.h](https://github.com/mongoose-os-libs/rpc-common/blob/master/include/mg_rpc.h)",
    "doc": "\n```c\nvoid mg_rpc_remove_channel(struct mg_rpc *c, struct mg_rpc_channel *ch);\n```\n>  Remove a channel from the instance. \n",
    "lang": "c"
  },
  {
    "name": "mg_rpc_connect",
    "file": "[mg_rpc.h](https://github.com/mongoose-os-libs/rpc-common/blob/master/include/mg_rpc.h)",
    "doc": "\n```c\nvoid mg_rpc_connect(struct mg_rpc *c);\n```\n>  Invokes connect method on all channels of this instance. \n",
    "lang": "c"
  },
  {
    "name": "mg_rpc_disconnect",
    "file": "[mg_rpc.h](https://github.com/mongoose-os-libs/rpc-common/blob/master/include/mg_rpc.h)",
    "doc": "\n```c\nvoid mg_rpc_disconnect(struct mg_rpc *c);\n```\n>  Invokes close method on all channels of this instance. \n",
    "lang": "c"
  },
  {
    "name": "mg_rpc_add_local_id",
    "file": "[mg_rpc.h](https://github.com/mongoose-os-libs/rpc-common/blob/master/include/mg_rpc.h)",
    "doc": "\n```c\nvoid mg_rpc_add_local_id(struct mg_rpc *c, const struct mg_str id);\n```\n> \n> Add a local ID. Frames with this `dst` will be considered addressed to this\n> instance.\n>  \n",
    "lang": "c"
  },
  {
    "name": "(*mg_result_cb_t)",
    "file": "[mg_rpc.h](https://github.com/mongoose-os-libs/rpc-common/blob/master/include/mg_rpc.h)",
    "doc": "\n```c\ntypedef void (*mg_result_cb_t)(struct mg_rpc *c, void *cb_arg,\n                               struct mg_rpc_frame_info *fi,\n                               struct mg_str result, int error_code,\n                               struct mg_str error_msg);\n```\n>  Signature of the function that receives response to a request. \n",
    "lang": "c"
  },
  {
    "name": "mg_rpc_callf",
    "file": "[mg_rpc.h](https://github.com/mongoose-os-libs/rpc-common/blob/master/include/mg_rpc.h)",
    "doc": "\n```c\nbool mg_rpc_callf(struct mg_rpc *c, const struct mg_str method,\n                  mg_result_cb_t cb, void *cb_arg,\n                  const struct mg_rpc_call_opts *opts, const char *args_jsonf,\n                  ...);\n```\n> \n> Make an RPC call.\n> The destination RPC server is specified by `opts`, and destination\n> RPC service name is `method`.\n> `cb` callback function is optional, in which case request is sent but\n> response is not required.\n> opts can be NULL, in which case the default destination is used.\n> Example - calling a remote RPC server over websocket:\n> \n> ```c\n> struct mg_rpc_call_opts opts = {.dst = mg_mk_str(\"ws://1.2.3.4/foo\") };\n> mg_rpc_callf(mgos_rpc_get_global(), mg_mk_str(\"My.Func\"), NULL, NULL, &opts,\n>              \"{param1: %Q, param2: %d}\", \"jaja\", 1234);\n> ```\n> It is possible to call RPC services running locally. In this case,\n> include the https://github.com/mongoose-os-libs/rpc-loopback library,\n> and use `MGOS_RPC_LOOPBACK_ADDR` special destination address:\n> \n> ```c\n> #include \"mg_rpc_channel_loopback.h\"\n> struct mg_rpc_call_opts opts = {.dst = mg_mk_str(MGOS_RPC_LOOPBACK_ADDR) };\n> ```\n>  \n",
    "lang": "c"
  },
  {
    "name": "mg_rpc_vcallf",
    "file": "[mg_rpc.h](https://github.com/mongoose-os-libs/rpc-common/blob/master/include/mg_rpc.h)",
    "doc": "\n```c\nbool mg_rpc_vcallf(struct mg_rpc *c, const struct mg_str method,\n                   mg_result_cb_t cb, void *cb_arg,\n                   const struct mg_rpc_call_opts *opts, const char *args_jsonf,\n                   va_list ap);\n```\n>  Same as mg_rpc_callf, but takes va_list ap \n",
    "lang": "c"
  },
  {
    "name": "(*mg_handler_cb_t)",
    "file": "[mg_rpc.h](https://github.com/mongoose-os-libs/rpc-common/blob/master/include/mg_rpc.h)",
    "doc": "\n```c\ntypedef void (*mg_handler_cb_t)(struct mg_rpc_request_info *ri, void *cb_arg,\n                                struct mg_rpc_frame_info *fi,\n                                struct mg_str args);\n```\n> \n> Signature of an incoming request handler.\n> Note that only request_info remains valid after return from this function,\n> frame_info and args will be invalidated.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mg_rpc_add_handler",
    "file": "[mg_rpc.h](https://github.com/mongoose-os-libs/rpc-common/blob/master/include/mg_rpc.h)",
    "doc": "\n```c\nvoid mg_rpc_add_handler(struct mg_rpc *c, const char *method,\n                        const char *args_fmt, mg_handler_cb_t cb, void *cb_arg);\n```\n> \n> Add a method handler.\n> `method` can be a pattern, e.g. `Foo.*` will match calls to `Foo.Bar`.\n> Matching is case-insensitive so invoking `foo.bar` will also work.\n>  \n",
    "lang": "c"
  },
  {
    "name": "(*mg_prehandler_cb_t)",
    "file": "[mg_rpc.h](https://github.com/mongoose-os-libs/rpc-common/blob/master/include/mg_rpc.h)",
    "doc": "\n```c\ntypedef bool (*mg_prehandler_cb_t)(struct mg_rpc_request_info *ri, void *cb_arg,\n                                   struct mg_rpc_frame_info *fi,\n                                   struct mg_str args);\n```\n> \n> Signature of an incoming requests prehandler, which is called right before\n> calling the actual handler.\n> \n> If it returns false, the further request processing is not performed. It's\n> called for existing handlers only.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mg_rpc_set_prehandler",
    "file": "[mg_rpc.h](https://github.com/mongoose-os-libs/rpc-common/blob/master/include/mg_rpc.h)",
    "doc": "\n```c\nvoid mg_rpc_set_prehandler(struct mg_rpc *c, mg_prehandler_cb_t cb,\n                           void *cb_arg);\n```\n>  Set a generic method prehandler. \n",
    "lang": "c"
  },
  {
    "name": "mg_rpc_send_responsef",
    "file": "[mg_rpc.h](https://github.com/mongoose-os-libs/rpc-common/blob/master/include/mg_rpc.h)",
    "doc": "\n```c\nbool mg_rpc_send_responsef(struct mg_rpc_request_info *ri,\n                           const char *result_json_fmt, ...);\n```\n> \n> Respond to an incoming request.\n> result_json_fmt can be NULL, in which case no result is included.\n> `ri` is freed by the call, so it's illegal to use it afterwards.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mg_rpc_send_errorf",
    "file": "[mg_rpc.h](https://github.com/mongoose-os-libs/rpc-common/blob/master/include/mg_rpc.h)",
    "doc": "\n```c\nbool mg_rpc_send_errorf(struct mg_rpc_request_info *ri, int error_code,\n                        const char *error_msg_fmt, ...);\n```\n> \n> Send and error response to an incoming request.\n> error_msg_fmt is optional and can be NULL, in which case only code is sent.\n> `ri` is freed by the call, so it's illegal to use it afterwards.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mg_rpc_send_error_jsonf",
    "file": "[mg_rpc.h](https://github.com/mongoose-os-libs/rpc-common/blob/master/include/mg_rpc.h)",
    "doc": "\n```c\nbool mg_rpc_send_error_jsonf(struct mg_rpc_request_info *ri, int error_code,\n                             const char *error_json_fmt, ...);\n```\n> \n> Like mg_rpc_send_errorf, but uses JSON formatting, see json_printf().\n> NOTE: \"error.message\" will still be a string but will contain serialized\n> JSON formatted accordingly to error_json_fmt.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mg_rpc_is_connected",
    "file": "[mg_rpc.h](https://github.com/mongoose-os-libs/rpc-common/blob/master/include/mg_rpc.h)",
    "doc": "\n```c\nbool mg_rpc_is_connected(struct mg_rpc *c);\n```\n>  Returns true if the instance has an open default channel. \n",
    "lang": "c"
  },
  {
    "name": "mg_rpc_can_send",
    "file": "[mg_rpc.h](https://github.com/mongoose-os-libs/rpc-common/blob/master/include/mg_rpc.h)",
    "doc": "\n```c\nbool mg_rpc_can_send(struct mg_rpc *c);\n```\n>  Returns true if the instance has an open default channel\n> and it's not currently busy. \n",
    "lang": "c"
  },
  {
    "name": "mg_rpc_get_channel_info",
    "file": "[mg_rpc.h](https://github.com/mongoose-os-libs/rpc-common/blob/master/include/mg_rpc.h)",
    "doc": "\n```c\nbool mg_rpc_get_channel_info(struct mg_rpc *c, struct mg_rpc_channel_info **ci,\n                             int *num_ci);\nvoid mg_rpc_channel_info_free(struct mg_rpc_channel_info *ci);\nvoid mg_rpc_channel_info_free_all(struct mg_rpc_channel_info *ci, int num_ci);\n```\n> \n> Retrieve information about currently active channels.\n> Results are heap-allocated and must be freed all together with\n> mg_rpc_channel_info_free_all() or individuallt with\n> mg_rpc_channel_info_free().\n> Note: mg_rpc_channel_info_free_all does not free the pointer passed to it.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mg_rpc_add_list_handler",
    "file": "[mg_rpc.h](https://github.com/mongoose-os-libs/rpc-common/blob/master/include/mg_rpc.h)",
    "doc": "\n```c\nvoid mg_rpc_add_list_handler(struct mg_rpc *c);\n```\n>  Enable RPC.List handler that returns a list of all registered endpoints \n",
    "lang": "c"
  },
  {
    "name": "mg_rpc_parse_frame",
    "file": "[mg_rpc.h](https://github.com/mongoose-os-libs/rpc-common/blob/master/include/mg_rpc.h)",
    "doc": "\n```c\nbool mg_rpc_parse_frame(const struct mg_str f, struct mg_rpc_frame *frame);\n```\n> \n> Parses frame `f` and stores result into `frame`. Returns true in case of\n> success, false otherwise.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mg_rpc_check_digest_auth",
    "file": "[mg_rpc.h](https://github.com/mongoose-os-libs/rpc-common/blob/master/include/mg_rpc.h)",
    "doc": "\n```c\nbool mg_rpc_check_digest_auth(struct mg_rpc_request_info *ri);\n```\n> \n> Checks whether digest auth creds were provided and were correct. After that\n> call, the caller should check whether the authn was successful by checking\n> if `ri->authn_info.username.len` is not empty.\n> \n> If some error has happened, like failure to open `htdigest` file, sends\n> an error response and returns false (in this case, `ri` is not valid\n> anymore). Otherwise returns true.\n> \n> NOTE: returned true does not necessarily mean the successful authentication.\n>  \n",
    "lang": "c"
  },
  {
    "name": "RPC.addHandler(name, handler)",
    "file": "[api_rpc.js](https://github.com/mongoose-os-libs/rpc-common/blob/master/mjs_fs/api_rpc.js)",
    "doc": "\n```javascript\nRPC.addHandler(name, handler)\n```\nAdd RPC handler. `name` is a string like `'MyMethod'`, `handler`\nis a callback function which takes `args` arguments object.\nIf a handler returns an object with a numeric `error` attribute and\noptional `message` string attribute, the caller will get a failure.\n\nReturn value: none.\n\nExample:\n```javascript\nRPC.addHandler('Sum', function(args) {\n  if (typeof(args) === 'object' && typeof(args.a) === 'number' &&\n      typeof(args.b) === 'number') {\n    return args.a + args.b;\n  } else {\n    return {error: -1, message: 'Bad request. Expected: {\"a\":N1,\"b\":N2}'};\n  }\n});\n```\n",
    "lang": "js"
  },
  {
    "name": "RPC.call(dst, method, args, callback)",
    "file": "[api_rpc.js](https://github.com/mongoose-os-libs/rpc-common/blob/master/mjs_fs/api_rpc.js)",
    "doc": "\n```javascript\nRPC.call(dst, method, args, callback)\n```\nCall remote or local RPC service.\nReturn value: true in case of success, false otherwise.\n\nIf `dst` is empty, connected server is implied. `method` is a string\nlike \"MyMethod\", `callback` is a callback function which takes the following\narguments: res (results object), err_code (0 means success, or error code\notherwise), err_msg (error messasge for non-0 error code), userdata. Example:\n\n```javascript\nRPC.call(RPC.LOCAL, 'Config.Save', {reboot: true}, function (resp, err_code, err_msg, ud) {\n  if (err_code !== 0) {\n    print(\"Error: (\" + JSON.stringify(err_code) + ') ' + err_msg);\n  } else {\n    print('Result: ' + JSON.stringify(result));\n  }\n}, null);\n```\n",
    "lang": "js"
  },
  {
    "name": "mg_rpc_channel_loopback",
    "file": "[mg_rpc_channel_loopback.h](https://github.com/mongoose-os-libs/rpc-loopback/blob/master/include/mg_rpc_channel_loopback.h)",
    "doc": "\n```c\nstruct mg_rpc_channel *mg_rpc_channel_loopback(void);\n```\n> \n> Creates a new loopback channel. Should be called for each incoming loopback\n> request; `nc` is an incoming connection.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mg_rpc_channel_mqtt",
    "file": "[mgos_rpc_channel_mqtt.h](https://github.com/mongoose-os-libs/rpc-mqtt/blob/master/include/mgos_rpc_channel_mqtt.h)",
    "doc": "\n```c\nstruct mg_rpc_channel *mg_rpc_channel_mqtt(const struct mg_str device_id);\n```\n>  __cplusplus \n",
    "lang": "c"
  },
  {
    "name": "mgos_rpc_service_config_init",
    "file": "[mgos_service_config.h](https://github.com/mongoose-os-libs/rpc-service-config/blob/master/include/mgos_service_config.h)",
    "doc": "\n```c\nbool mgos_rpc_service_config_init(void);\n```\n> \n> Initialises mg_rpc handlers for Config commands\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_rpc_service_fs_init",
    "file": "[mgos_service_filesystem.h](https://github.com/mongoose-os-libs/rpc-service-fs/blob/master/include/mgos_service_filesystem.h)",
    "doc": "\n```c\nbool mgos_rpc_service_fs_init(void);\n```\n> \n> Initialises mg_rpc handlers for FS commands\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_rpc_service_gpio_init",
    "file": "[mgos_gpio_service.h](https://github.com/mongoose-os-libs/rpc-service-gpio/blob/master/include/mgos_gpio_service.h)",
    "doc": "\n```c\nbool mgos_rpc_service_gpio_init(void);\n```\n>  __cplusplus \n",
    "lang": "c"
  },
  {
    "name": "mgos_rpc_service_i2c_init",
    "file": "[mgos_i2c_service.h](https://github.com/mongoose-os-libs/rpc-service-i2c/blob/master/include/mgos_i2c_service.h)",
    "doc": "\n```c\nbool mgos_rpc_service_i2c_init(void);\n```\n>  __cplusplus \n",
    "lang": "c"
  },
  {
    "name": "mgos_rpc_service_ota_init",
    "file": "[mgos_rpc_service_ota.h](https://github.com/mongoose-os-libs/rpc-service-ota/blob/master/include/mgos_rpc_service_ota.h)",
    "doc": "\n```c\nbool mgos_rpc_service_ota_init(void);\nvoid mgos_updater_rpc_finish(int error_code, int64_t id,\n                             const struct mg_str src);\n```\n>  __cplusplus \n",
    "lang": "c"
  },
  {
    "name": "mg_rpc_channel_uart",
    "file": "[mgos_rpc_channel_uart.h](https://github.com/mongoose-os-libs/rpc-uart/blob/master/include/mgos_rpc_channel_uart.h)",
    "doc": "\n```c\nstruct mg_rpc_channel *mg_rpc_channel_uart(\n    const struct mgos_config_rpc_uart *cfg,\n    const struct mgos_uart_config *ucfg);\n```\n>  __cplusplus \n",
    "lang": "c"
  },
  {
    "name": "MGOS_EVENT_BASE",
    "file": "[mgos_shadow.h](https://github.com/mongoose-os-libs/shadow/blob/master/include/mgos_shadow.h)",
    "doc": "\n```c\n#define MGOS_SHADOW_BASE MGOS_EVENT_BASE('S', 'D', 'W')\n```\n>  __cplusplus \n",
    "lang": "c"
  },
  {
    "name": "mgos_shadow_event_name",
    "file": "[mgos_shadow.h](https://github.com/mongoose-os-libs/shadow/blob/master/include/mgos_shadow.h)",
    "doc": "\n```c\nconst char *mgos_shadow_event_name(int ev);\n```\n>  Stringify shadow event name \n",
    "lang": "c"
  },
  {
    "name": "mgos_shadow_get",
    "file": "[mgos_shadow.h](https://github.com/mongoose-os-libs/shadow/blob/master/include/mgos_shadow.h)",
    "doc": "\n```c\nbool mgos_shadow_get(void);\n```\n> \n> Request shadow state. Response will arrive via GET_ACCEPTED topic.\n> Note that MGOS automatically does this on every (re)connect if\n> device.shadow.get_on_connect is true (default).\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_shadow_updatef",
    "file": "[mgos_shadow.h](https://github.com/mongoose-os-libs/shadow/blob/master/include/mgos_shadow.h)",
    "doc": "\n```c\nbool mgos_shadow_updatef(uint64_t version, const char *state_jsonf, ...);\n```\n> \n> Send an update. Format string should define the value of the \"state\" key,\n> i.e. it should be an object with an update to the reported state, e.g.:\n> `mgos_shadow_updatef(\"{foo: %d, bar: %d}\", foo, bar)`.\n> Response will arrive via UPDATE_ACCEPTED or REJECTED topic.\n> If you want the update to be aplied only if a particular version is\n> current,\n> specify the version. Otherwise set it to 0 to apply to any version.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_shadow_update",
    "file": "[mgos_shadow.h](https://github.com/mongoose-os-libs/shadow/blob/master/include/mgos_shadow.h)",
    "doc": "\n```c\nbool mgos_shadow_update(double version, const char *state_json);\n```\n>  \"Simple\" version of mgos_shadow_updatef, primarily for FFI.  \n",
    "lang": "c"
  },
  {
    "name": "Shadow.addHandler(callback)",
    "file": "[api_shadow.js](https://github.com/mongoose-os-libs/shadow/blob/master/mjs_fs/api_shadow.js)",
    "doc": "\n```javascript\nShadow.addHandler(callback)\n```\nSet up shadow event handler. Callback receives `event, obj` parameters.\nPossibble values for `event` are:\n`CONNECTED`,  `UPDATE_ACCEPTED`, `UPDATE_REJECTED`,`UPDATE_DELTA`.\n`obj` is an shadow object, valid for `UPDATE_DELTA` and `UPDATE_ACCEPTED`\nevents.\nSee https://github.com/mongoose-os-apps/example-shadow-js for the\nidiomatic usage.\n",
    "lang": "js"
  },
  {
    "name": "Shadow.get()",
    "file": "[api_shadow.js](https://github.com/mongoose-os-libs/shadow/blob/master/mjs_fs/api_shadow.js)",
    "doc": "\n```javascript\nShadow.get()\n```\nAsk cloud for the shadow. The reply will come as either `GET_ACCEPTED`\nevent or `GET_REJECTED` event.\n",
    "lang": "js"
  },
  {
    "name": "Shadow.update()",
    "file": "[api_shadow.js](https://github.com/mongoose-os-libs/shadow/blob/master/mjs_fs/api_shadow.js)",
    "doc": "\n```javascript\nShadow.update()\n```\nSend shadow update. The idiomatic way of using shadow is: a) catch\n`CONNECTED` event and report the current state, and b) catch `UPDATE_DELTA`\nevent, apply the delta, and report the state. Example:\n```javascript\nShadow.update(0, {temperature: 12.34});\n```\n",
    "lang": "js"
  },
  {
    "name": "_read",
    "file": "[mgos_sht31.h](https://github.com/mongoose-os-libs/sht31-i2c/blob/master/include/mgos_sht31.h)",
    "doc": "\n```c\nuint32_t read;                 // calls to _read()\n  uint32_t read_success;         // successful _read()\n  uint32_t read_success_cached;  // calls to _read() which were cached\n  // Note: read_errors := read - read_success - read_success_cached\n  double   read_success_usecs;   // time spent in successful uncached _read()\n};\n```\n> value of mg_time() upon last call to _read()\n",
    "lang": "c"
  },
  {
    "name": "mgos_sht31_create",
    "file": "[mgos_sht31.h](https://github.com/mongoose-os-libs/sht31-i2c/blob/master/include/mgos_sht31.h)",
    "doc": "\n```c\nstruct mgos_sht31 *mgos_sht31_create(struct mgos_i2c *i2c, uint8_t i2caddr);\n```\n> \n> Initialize a SHT31 on the I2C bus `i2c` at address specified in `i2caddr`\n> parameter (default SHT31 is on address 0x44). The sensor will be polled for\n> validity, upon success a new `struct mgos_sht31` is allocated and\n> returned. If the device could not be found, NULL is returned.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_sht31_destroy",
    "file": "[mgos_sht31.h](https://github.com/mongoose-os-libs/sht31-i2c/blob/master/include/mgos_sht31.h)",
    "doc": "\n```c\nvoid mgos_sht31_destroy(struct mgos_sht31 **sensor);\n```\n> \n> Destroy the data structure associated with a SHT31 device. The reference\n> to the pointer of the `struct mgos_sht31` has to be provided, and upon\n> successful destruction, its associated memory will be freed and the pointer\n> set to NULL.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_sht31_read",
    "file": "[mgos_sht31.h](https://github.com/mongoose-os-libs/sht31-i2c/blob/master/include/mgos_sht31.h)",
    "doc": "\n```c\nbool mgos_sht31_read(struct mgos_sht31 *sensor);\n```\n> \n> The sensor will be polled for its temperature and humidity data. If the poll\n> has occured in the last `MGOS_SHT31_READ_DELAY` seconds, the cached data is\n> used (so as not to repeatedly poll the bus upon subsequent calls).\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_sht31_getTemperature",
    "file": "[mgos_sht31.h](https://github.com/mongoose-os-libs/sht31-i2c/blob/master/include/mgos_sht31.h)",
    "doc": "\n```c\nfloat mgos_sht31_getTemperature(struct mgos_sht31 *sensor);\n```\n> \n> The sensor will be polled for its temperature and humidity data. If the poll\n> has occured in the last `MGOS_SHT31_READ_DELAY` seconds, the cached data is\n> used (so as not to repeatedly poll the bus upon subsequent calls).\n> \n> The return value is the temperature of the sensor in Celsius, or NAN if no\n> data was found.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_sht31_getHumidity",
    "file": "[mgos_sht31.h](https://github.com/mongoose-os-libs/sht31-i2c/blob/master/include/mgos_sht31.h)",
    "doc": "\n```c\nfloat mgos_sht31_getHumidity(struct mgos_sht31 *sensor);\n```\n> \n> The sensor will be polled for its temperature and humidity data. If the poll\n> has occured in the last `MGOS_SHT31_READ_DELAY` seconds, the cached data is\n> used (so as not to repeatedly poll the bus upon subsequent calls).\n> \n> The return value is the humidity of the sensor in percent relative humidity,\n> or NAN if no data was found.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_sht31_getStats",
    "file": "[mgos_sht31.h](https://github.com/mongoose-os-libs/sht31-i2c/blob/master/include/mgos_sht31.h)",
    "doc": "\n```c\nbool mgos_sht31_getStats(struct mgos_sht31 *sensor, struct mgos_sht31_stats *stats);\n```\n> \n> Returns the running statistics on the sensor interaction, the user provides\n> a pointer to a `struct mgos_sht31_stats` object, which is filled in by this\n> call.\n> \n> Upon success, true is returned. Otherwise, false is returned, in which case\n> the contents of `stats` is undetermined.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_sht31_i2c_init",
    "file": "[mgos_sht31.h](https://github.com/mongoose-os-libs/sht31-i2c/blob/master/include/mgos_sht31.h)",
    "doc": "\n```c\nbool mgos_sht31_i2c_init(void);\n```\n> \n> Initialization function for MGOS -- currently a noop.\n>  \n",
    "lang": "c"
  },
  {
    "name": "si7005_probe",
    "file": "[si7005.h](https://github.com/mongoose-os-libs/si7005/blob/master/include/si7005.h)",
    "doc": "\n```c\nbool si7005_probe(void);\n```\n>  Returns true if a sensor is present on the bus. \n",
    "lang": "c"
  },
  {
    "name": "si7005_read_temp",
    "file": "[si7005.h](https://github.com/mongoose-os-libs/si7005/blob/master/include/si7005.h)",
    "doc": "\n```c\nfloat si7005_read_temp(void);\n```\n>  Performs conversion and returns temperature, in C, or INVALID_VALUE \n",
    "lang": "c"
  },
  {
    "name": "si7005_read_rh",
    "file": "[si7005.h](https://github.com/mongoose-os-libs/si7005/blob/master/include/si7005.h)",
    "doc": "\n```c\nfloat si7005_read_rh(void);\n```\n> \n> Performs conversion and returns relative humidity, in %, or INVALID_VALUE.\n> Note: Performs temperature measurement prior to the RH to perform temperature\n> compensation.\n>  \n",
    "lang": "c"
  },
  {
    "name": "si7005_set_heater",
    "file": "[si7005.h](https://github.com/mongoose-os-libs/si7005/blob/master/include/si7005.h)",
    "doc": "\n```c\nbool si7005_set_heater(bool on);\n```\n>  Turns the built-in heater element on or off. \n",
    "lang": "c"
  },
  {
    "name": "si7005_probe_bus",
    "file": "[si7005.h](https://github.com/mongoose-os-libs/si7005/blob/master/include/si7005.h)",
    "doc": "\n```c\nbool si7005_probe_bus(struct mgos_i2c *i2c);\nfloat si7005_read_temp_bus(struct mgos_i2c *i2c);\nfloat si7005_read_rh_bus(struct mgos_i2c *i2c);\nbool si7005_set_heater_bus(struct mgos_i2c *i2c, bool on);\n```\n>  Variants of the simple blocking methods above with custom bus. \n",
    "lang": "c"
  },
  {
    "name": "si7005_start_conversion",
    "file": "[si7005.h](https://github.com/mongoose-os-libs/si7005/blob/master/include/si7005.h)",
    "doc": "\n```c\nbool si7005_start_conversion(struct mgos_i2c *i2c, bool temp, bool fast);\n```\n>  Start temperature or humidity conversion. \n",
    "lang": "c"
  },
  {
    "name": "si7005_is_data_ready",
    "file": "[si7005.h](https://github.com/mongoose-os-libs/si7005/blob/master/include/si7005.h)",
    "doc": "\n```c\nbool si7005_is_data_ready(struct mgos_i2c *i2c);\n```\n>  Check if the data is ready. \n",
    "lang": "c"
  },
  {
    "name": "si7005_read_data",
    "file": "[si7005.h](https://github.com/mongoose-os-libs/si7005/blob/master/include/si7005.h)",
    "doc": "\n```c\nfloat si7005_read_data(struct mgos_i2c *i2c, bool temp);\n```\n> \n> Read out the data.\n> Note that RH value is linearized but not temp-compensated.\n>  \n",
    "lang": "c"
  },
  {
    "name": "si7005_rh_tcomp",
    "file": "[si7005.h](https://github.com/mongoose-os-libs/si7005/blob/master/include/si7005.h)",
    "doc": "\n```c\nfloat si7005_rh_tcomp(float rh_val, float temp);\n```\n>  Perform temperature compensation of the RH reading. \n",
    "lang": "c"
  },
  {
    "name": "_read",
    "file": "[mgos_si7021.h](https://github.com/mongoose-os-libs/si7021-i2c/blob/master/include/mgos_si7021.h)",
    "doc": "\n```c\nuint32_t read;                 // calls to _read()\n  uint32_t read_success;         // successful _read()\n  uint32_t read_success_cached;  // calls to _read() which were cached\n  // Note: read_errors := read - read_success - read_success_cached\n  double   read_success_usecs;   // time spent in successful uncached _read()\n};\n```\n> value of mg_time() upon last call to _read()\n",
    "lang": "c"
  },
  {
    "name": "mgos_si7021_create",
    "file": "[mgos_si7021.h](https://github.com/mongoose-os-libs/si7021-i2c/blob/master/include/mgos_si7021.h)",
    "doc": "\n```c\nstruct mgos_si7021 *mgos_si7021_create(struct mgos_i2c *i2c, uint8_t i2caddr);\n```\n> \n> Initialize a Si7021 on the I2C bus `i2c` at address specified in `i2caddr`\n> parameter (default Si7021 is on address 0x40). The sensor will be polled for\n> validity, upon success a new `struct mgos_si7021` is allocated and\n> returned. If the device could not be found, NULL is returned.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_si7021_destroy",
    "file": "[mgos_si7021.h](https://github.com/mongoose-os-libs/si7021-i2c/blob/master/include/mgos_si7021.h)",
    "doc": "\n```c\nvoid mgos_si7021_destroy(struct mgos_si7021 **sensor);\n```\n> \n> Destroy the data structure associated with a Si7021 device. The reference\n> to the pointer of the `struct mgos_si7021` has to be provided, and upon\n> successful destruction, its associated memory will be freed and the pointer\n> set to NULL.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_si7021_read",
    "file": "[mgos_si7021.h](https://github.com/mongoose-os-libs/si7021-i2c/blob/master/include/mgos_si7021.h)",
    "doc": "\n```c\nbool mgos_si7021_read(struct mgos_si7021 *sensor);\n```\n> \n> The sensor will be polled for its temperature and humidity data. If the poll\n> has occured in the last `MGOS_SI7021_READ_DELAY` seconds, the cached data is\n> used (so as not to repeatedly poll the bus upon subsequent calls).\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_si7021_getTemperature",
    "file": "[mgos_si7021.h](https://github.com/mongoose-os-libs/si7021-i2c/blob/master/include/mgos_si7021.h)",
    "doc": "\n```c\nfloat mgos_si7021_getTemperature(struct mgos_si7021 *sensor);\n```\n> \n> The sensor will be polled for its temperature and humidity data. If the poll\n> has occured in the last `MGOS_SI7021_READ_DELAY` seconds, the cached data is\n> used (so as not to repeatedly poll the bus upon subsequent calls).\n> \n> The return value is the temperature of the sensor in Celsius, or NAN if no\n> data was found.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_si7021_getHumidity",
    "file": "[mgos_si7021.h](https://github.com/mongoose-os-libs/si7021-i2c/blob/master/include/mgos_si7021.h)",
    "doc": "\n```c\nfloat mgos_si7021_getHumidity(struct mgos_si7021 *sensor);\n```\n> \n> The sensor will be polled for its temperature and humidity data. If the poll\n> has occured in the last `MGOS_SI7021_READ_DELAY` seconds, the cached data is\n> used (so as not to repeatedly poll the bus upon subsequent calls).\n> \n> The return value is the humidity of the sensor in percent relative humidity,\n> or NAN if no data was found.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_si7021_getStats",
    "file": "[mgos_si7021.h](https://github.com/mongoose-os-libs/si7021-i2c/blob/master/include/mgos_si7021.h)",
    "doc": "\n```c\nbool mgos_si7021_getStats(struct mgos_si7021 *sensor, struct mgos_si7021_stats *stats);\n```\n> \n> Returns the running statistics on the sensor interaction, the user provides\n> a pointer to a `struct mgos_si7021_stats` object, which is filled in by this\n> call.\n> \n> Upon success, true is returned. Otherwise, false is returned, in which case\n> the contents of `stats` is undetermined.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_si7021_i2c_init",
    "file": "[mgos_si7021.h](https://github.com/mongoose-os-libs/si7021-i2c/blob/master/include/mgos_si7021.h)",
    "doc": "\n```c\nbool mgos_si7021_i2c_init(void);\n```\n> \n> Initialization function for MGOS -- currently a noop.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_spi_create",
    "file": "[mgos_spi.h](https://github.com/mongoose-os-libs/spi/blob/master/include/mgos_spi.h)",
    "doc": "\n```c\nstruct mgos_spi *mgos_spi_create(const struct mgos_config_spi *cfg);\n```\n>  Initialize SPI master. \n",
    "lang": "c"
  },
  {
    "name": "mgos_spi_configure",
    "file": "[mgos_spi.h](https://github.com/mongoose-os-libs/spi/blob/master/include/mgos_spi.h)",
    "doc": "\n```c\nbool mgos_spi_configure(struct mgos_spi *spi,\n                        const struct mgos_config_spi *cfg);\n```\n>  (Re)configure existing SPI interface. \n",
    "lang": "c"
  },
  {
    "name": "mgos_spi_run_txn",
    "file": "[mgos_spi.h](https://github.com/mongoose-os-libs/spi/blob/master/include/mgos_spi.h)",
    "doc": "\n```c\nbool mgos_spi_run_txn(struct mgos_spi *spi, bool full_duplex,\n                      const struct mgos_spi_txn *txn);\n```\n> \n> Execute a half-duplex transaction. See `struct mgos_spi_txn` for the details\n> on transaction params.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_spi_close",
    "file": "[mgos_spi.h](https://github.com/mongoose-os-libs/spi/blob/master/include/mgos_spi.h)",
    "doc": "\n```c\nvoid mgos_spi_close(struct mgos_spi *spi);\n```\n>  Close SPI handle. \n",
    "lang": "c"
  },
  {
    "name": "mgos_spi_get_global",
    "file": "[mgos_spi.h](https://github.com/mongoose-os-libs/spi/blob/master/include/mgos_spi.h)",
    "doc": "\n```c\nstruct mgos_spi *mgos_spi_get_global(void);\n```\n>  Return global SPI bus handle which is configured via sysconfig. \n",
    "lang": "c"
  },
  {
    "name": "SPI.get()",
    "file": "[api_spi.js](https://github.com/mongoose-os-libs/spi/blob/master/mjs_fs/api_spi.js)",
    "doc": "\n```javascript\nSPI.get()\n```\nGet SPI bus handle. Return value: opaque pointer.\n",
    "lang": "js"
  },
  {
    "name": "SPI.runTransaction(spi, param)",
    "file": "[api_spi.js](https://github.com/mongoose-os-libs/spi/blob/master/mjs_fs/api_spi.js)",
    "doc": "\n```javascript\nSPI.runTransaction(spi, param)\n```\nRun SPI transaction, which might be a half-duplex or a full-duplex one.\n\nHalf-duplex transaction includes one or more of the following:\n- Writing data,\n- Waiting for dummy bytes,\n- Reading data.\n\nFull-duplex transaction performs writing and reading at the same time.\n\nWhether the transaction is half-duplex or full-duplex is determined by\ngiven params: if \"fd\" property is set, it's a full-duplex transaction;\notherwise \"hd\" property should be set (see details below).\n\n`spi` is an SPI instance, e.g. the one returned by `SPI.get()`.\n`param` is an object with the following parameters:\n\n```javascript\n{\n  // Which CS line to use, 0, 1 or 2. use -1 to not assert any CS\n  // during transaction, it is assumed to be done externally.\n  // Note: this is not a GPIO number, mapping from cs to GPIO is set in\n  // the device configuration.\n  cs: 0,\n\n  // Mode, 0-3. This controls clock phase and polarity.\n  mode: 0,\n\n  // Clock frequency to use. 0 means don't change.\n  freq: 2000000,\n\n  // Half-duplex transaction parameters\n  hd: {\n    // A string with data to transmit. If undefined, no data is transmitted.\n    tx_data: \"foobar\",\n\n    // Number of dummy bytes to wait for. If undefined, 0 is assumed.\n    dummy_len: 1,\n\n    // Number of bytes to read.\n    rx_len: 3,\n  },\n\n  // Full-duplex transaction parameters\n  fd: {\n    // A string with data to transmit. Equal number of bytes will be read.\n    tx_data: \"foo\",\n  },\n}\n```\n\nReturn value: a string with the data read (an empty string if no read was\nrequested), or `false` in case of an error.\n",
    "lang": "js"
  },
  {
    "name": "mgos_tmp006_setup",
    "file": "[mgos_tmp006.h](https://github.com/mongoose-os-libs/tmp006/blob/master/include/mgos_tmp006.h)",
    "doc": "\n```c\nbool mgos_tmp006_setup(struct mgos_i2c *bus, uint8_t addr,\n                       enum tmp006_conversion_rate rate, bool drdy_en);\n```\n> \n> Initialize TMP006 driver on the given I2C `bus` and `addr`, with\n> the given conversion rate (see `enum tmp006_conversion_rate`). To enable\n> `DRDY` pin, set `drdy_en` to `true`.\n> \n> Returns `true` in case of success, `false` otherwise.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_tmp006_get_voltage",
    "file": "[mgos_tmp006.h](https://github.com/mongoose-os-libs/tmp006/blob/master/include/mgos_tmp006.h)",
    "doc": "\n```c\ndouble mgos_tmp006_get_voltage(struct mgos_i2c *i2c, uint8_t addr);\n```\n> \n> Get voltage from the TMP006 sensor at the given i2c bus and addr. In case of\n> failure, returns `TMP006_INVALID_READING`.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_tmp006_get_die_temp",
    "file": "[mgos_tmp006.h](https://github.com/mongoose-os-libs/tmp006/blob/master/include/mgos_tmp006.h)",
    "doc": "\n```c\ndouble mgos_tmp006_get_die_temp(struct mgos_i2c *i2c, uint8_t addr);\n```\n> \n> Get temperature in C degrees from the TMP006 sensor at the given i2c bus and\n> addr. In case of failure, returns `TMP006_INVALID_READING`.\n>  \n",
    "lang": "c"
  },
  {
    "name": "_read",
    "file": "[mgos_veml6075.h](https://github.com/mongoose-os-libs/veml6075-i2c/blob/master/include/mgos_veml6075.h)",
    "doc": "\n```c\nuint32_t read;                 // calls to _read()\n  uint32_t read_success;         // successful _read()\n  uint32_t read_success_cached;  // calls to _read() which were cached\n  // Note: read_errors := read - read_success - read_success_cached\n  double   read_success_usecs;   // time spent in successful uncached _read()\n};\n```\n> value of mg_time() upon last call to _read()\n",
    "lang": "c"
  },
  {
    "name": "mgos_veml6075_create",
    "file": "[mgos_veml6075.h](https://github.com/mongoose-os-libs/veml6075-i2c/blob/master/include/mgos_veml6075.h)",
    "doc": "\n```c\nstruct mgos_veml6075 *mgos_veml6075_create(struct mgos_i2c *i2c, uint8_t i2caddr);\n```\n> \n> Initialize a VEML6075 on the I2C bus `i2c` at address specified in `i2caddr`\n> parameter (default VEML607 is on address 0x10). The sensor will be polled for\n> its deviceid, upon success a new `struct mgos_veml6075` is allocated and\n> returned. If the device could not be found, NULL is returned.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_veml6075_destroy",
    "file": "[mgos_veml6075.h](https://github.com/mongoose-os-libs/veml6075-i2c/blob/master/include/mgos_veml6075.h)",
    "doc": "\n```c\nvoid mgos_veml6075_destroy(struct mgos_veml6075 **sensor);\n```\n> \n> Destroy the data structure associated with a VEML6075 device. The reference\n> to the pointer of the `struct mgos_veml6075` has to be provided, and upon\n> successful destruction, its associated memory will be freed and the pointer\n> set to NULL.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_veml6075_getUVA",
    "file": "[mgos_veml6075.h](https://github.com/mongoose-os-libs/veml6075-i2c/blob/master/include/mgos_veml6075.h)",
    "doc": "\n```c\nfloat mgos_veml6075_getUVA(struct mgos_veml6075 *sensor);\n```\n> \n> The sensor will be polled for its light counter registers. If the poll has\n> occured in the last `MGOS_VEML6075_READ_DELAY` seconds, the cached data is\n> used (so as not to repeatedly poll the bus upon subsequent calls).\n> \n> The UVA band intensity is returned as a float (0.0 means \"no light\", higher\n> numbers mean more light was measured).\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_veml6075_getUVB",
    "file": "[mgos_veml6075.h](https://github.com/mongoose-os-libs/veml6075-i2c/blob/master/include/mgos_veml6075.h)",
    "doc": "\n```c\nfloat mgos_veml6075_getUVB(struct mgos_veml6075 *sensor);\n```\n> \n> The sensor will be polled for its light counter registers. If the poll has\n> occured in the last `MGOS_VEML6075_READ_DELAY` seconds, the cached data is\n> used (so as not to repeatedly poll the bus upon subsequent calls).\n> \n> The UVB band intensity is returned as a float (0.0 means \"no light\", higher\n> numbers mean more light was measured).\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_veml6075_getUVIndex",
    "file": "[mgos_veml6075.h](https://github.com/mongoose-os-libs/veml6075-i2c/blob/master/include/mgos_veml6075.h)",
    "doc": "\n```c\nfloat mgos_veml6075_getUVIndex(struct mgos_veml6075 *sensor);\n```\n> \n> The sensor will be polled for its light counter registers. If the poll has\n> occured in the last `MGOS_VEML6075_READ_DELAY` seconds, the cached data is\n> used (so as not to repeatedly poll the bus upon subsequent calls).\n> \n> Please see https://www.vishay.com/docs/84339/designingveml6075.pdf for\n> details.\n> \n> The UVIndex is computed from UVA, UVB, IR and Visual counters and returned.\n> *   <2.0  - Low UVIndex intensity\n> *   <5.5  - Moderate\n> *   <7.5  - High\n> *   <10.5 - Very High\n> *   >10.5 - Extreme UVIndex intensity\n> \n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_veml6075_getRawUVA",
    "file": "[mgos_veml6075.h](https://github.com/mongoose-os-libs/veml6075-i2c/blob/master/include/mgos_veml6075.h)",
    "doc": "\n```c\nuint16_t mgos_veml6075_getRawUVA(struct mgos_veml6075 *sensor);\n```\n> \n> Return raw counters for light measured in the UVA register.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_veml6075_getRawUVB",
    "file": "[mgos_veml6075.h](https://github.com/mongoose-os-libs/veml6075-i2c/blob/master/include/mgos_veml6075.h)",
    "doc": "\n```c\nuint16_t mgos_veml6075_getRawUVB(struct mgos_veml6075 *sensor);\n```\n> \n> Return raw counters for light measured in the UVB register.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_veml6075_getRawDark",
    "file": "[mgos_veml6075.h](https://github.com/mongoose-os-libs/veml6075-i2c/blob/master/include/mgos_veml6075.h)",
    "doc": "\n```c\nuint16_t mgos_veml6075_getRawDark(struct mgos_veml6075 *sensor);\n```\n> \n> Return raw counters for light measured in the RawDark register.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_veml6075_getRawVisComp",
    "file": "[mgos_veml6075.h](https://github.com/mongoose-os-libs/veml6075-i2c/blob/master/include/mgos_veml6075.h)",
    "doc": "\n```c\nuint16_t mgos_veml6075_getRawVisComp(struct mgos_veml6075 *sensor);\n```\n> \n> Return raw counters for light measured in the Visual register.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_veml6075_getRawIRComp",
    "file": "[mgos_veml6075.h](https://github.com/mongoose-os-libs/veml6075-i2c/blob/master/include/mgos_veml6075.h)",
    "doc": "\n```c\nuint16_t mgos_veml6075_getRawIRComp(struct mgos_veml6075 *sensor);\n```\n> \n> Return raw counters for light measured in the Infra Red register.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_veml6075_getStats",
    "file": "[mgos_veml6075.h](https://github.com/mongoose-os-libs/veml6075-i2c/blob/master/include/mgos_veml6075.h)",
    "doc": "\n```c\nbool mgos_veml6075_getStats(struct mgos_veml6075 *sensor, struct mgos_veml6075_stats *stats);\n```\n> \n> Returns the running statistics on the sensor interaction, the user provides\n> a pointer to a `struct mgos_veml6075_stats` object, which is filled in by this\n> call.\n> \n> Upon success, true is returned. Otherwise, false is returned, in which case\n> the contents of `stats` is undetermined.\n>  \n",
    "lang": "c"
  },
  {
    "name": "MGOS_VFS_VFD_TO_FS_FD",
    "file": "[mgos_vfs.h](https://github.com/mongoose-os-libs/vfs-common/blob/master/include/mgos_vfs.h)",
    "doc": "\n```c\n#define MGOS_VFS_VFD_TO_FS_FD(vfd) ((vfd) &0xff)\n```\n>  Convert virtual fd to filesystem-specific fd \n",
    "lang": "c"
  },
  {
    "name": "(",
    "file": "[mgos_vfs.h](https://github.com/mongoose-os-libs/vfs-common/blob/master/include/mgos_vfs.h)",
    "doc": "\n```c\n#define MMAP_NUM_MASK ((1 << MMAP_NUM_BITS) - 1)\n#define MMAP_ADDR_MASK ((1 << MMAP_ADDR_BITS) - 1)\n```\n> \n> Platform-dependent header should define the following macros:\n> \n> - MMAP_BASE: base address for mmapped points; e.g. ((void *) 0x10000000)\n> - MMAP_END:  end address for mmapped points; e.g. ((void *) 0x20000000)\n> \n> So with the example values given above, the range 0x10000000 - 0x20000000 is\n> used for all mmapped areas. We need to partition it further, by choosing the\n> optimal tradeoff between the max number of mmapped areas and the max size\n> of the mmapped area. Within the example range, we have 28 bits, and we\n> need to define two more macros which will define how these bits are used:\n> \n> - MMAP_ADDR_BITS: how many bits are used for the address within each\n>   mmapped area;\n> - MMAP_NUM_BITS: how many bits are used for the number of mmapped area.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_vfs_mmap_descs_cnt",
    "file": "[mgos_vfs.h](https://github.com/mongoose-os-libs/vfs-common/blob/master/include/mgos_vfs.h)",
    "doc": "\n```c\nint mgos_vfs_mmap_descs_cnt(void);\n```\n> \n> Returns total number of allocated mmap descriptors (not all of them might be\n> used at the moment)\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_vfs_mmap_desc_get",
    "file": "[mgos_vfs.h](https://github.com/mongoose-os-libs/vfs-common/blob/master/include/mgos_vfs.h)",
    "doc": "\n```c\nstruct mgos_vfs_mmap_desc *mgos_vfs_mmap_desc_get(int idx);\n#endif /* CS_MMAP */\n```\n> \n> Returns mmap descriptor at the given index\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_vfs_fs_register_type",
    "file": "[mgos_vfs.h](https://github.com/mongoose-os-libs/vfs-common/blob/master/include/mgos_vfs.h)",
    "doc": "\n```c\nbool mgos_vfs_fs_register_type(const char *type,\n                               const struct mgos_vfs_fs_ops *ops);\n```\n>  Register fielsystem type and make it available for use in mkfs and mount. \n",
    "lang": "c"
  },
  {
    "name": "mgos_vfs_mkfs",
    "file": "[mgos_vfs.h](https://github.com/mongoose-os-libs/vfs-common/blob/master/include/mgos_vfs.h)",
    "doc": "\n```c\nbool mgos_vfs_mkfs(const char *dev_type, const char *dev_opts,\n                   const char *fs_type, const char *fs_opts);\n```\n> \n> Create a filesystem.\n> First a device is created with given type and options and then filesystem\n> is created on it. Device and filesystem types must've been previosuly\n> registered and options have device and filesystem-specific format\n> and usually are JSON objects.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_vfs_mkfs_dev",
    "file": "[mgos_vfs.h](https://github.com/mongoose-os-libs/vfs-common/blob/master/include/mgos_vfs.h)",
    "doc": "\n```c\nbool mgos_vfs_mkfs_dev(struct mgos_vfs_dev *dev, const char *fs_type,\n                       const char *fs_opts);\nbool mgos_vfs_mkfs_dev_name(const char *dev_name, const char *fs_type,\n                            const char *fs_opts);\n```\n>  Create a filesystem on an existing device. \n",
    "lang": "c"
  },
  {
    "name": "mgos_vfs_mount",
    "file": "[mgos_vfs.h](https://github.com/mongoose-os-libs/vfs-common/blob/master/include/mgos_vfs.h)",
    "doc": "\n```c\nbool mgos_vfs_mount(const char *path, const char *dev_type,\n                    const char *dev_opts, const char *fs_type,\n                    const char *fs_opts);\n```\n> \n> Mount a filesystem.\n> First a device is created with given type and options and then filesystem\n> is mounted from it and attached to the VFS at a given path.\n> Path must start with a \"/\" and consist of one component, e.g. \"/mnt\".\n> Nested mounts are not currently supported, so \"/mnt/foo\" is not ok.\n> Device and filesystem types must've been previosly registered and options\n> have device and filesystem-specific format and usually are JSON objects.\n> If device type is NULL, device will be probed for known FS types.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_vfs_mount_dev_name",
    "file": "[mgos_vfs.h](https://github.com/mongoose-os-libs/vfs-common/blob/master/include/mgos_vfs.h)",
    "doc": "\n```c\nbool mgos_vfs_mount_dev_name(const char *path, const char *dev_name,\n                             const char *fs_type, const char *fs_opts);\n```\n> \n> Mount a filesystem from an existing device.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_vfs_umount",
    "file": "[mgos_vfs.h](https://github.com/mongoose-os-libs/vfs-common/blob/master/include/mgos_vfs.h)",
    "doc": "\n```c\nbool mgos_vfs_umount(const char *path);\n```\n> \n> Unmount a previously mounted filesystem.\n> Only filesystems with no open files can be unmounted.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_vfs_umount_all",
    "file": "[mgos_vfs.h](https://github.com/mongoose-os-libs/vfs-common/blob/master/include/mgos_vfs.h)",
    "doc": "\n```c\nvoid mgos_vfs_umount_all(void);\n```\n> \n> Unmount all the filesystems, regardless of open files.\n> Done only on reboot.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_vfs_get_space_total",
    "file": "[mgos_vfs.h](https://github.com/mongoose-os-libs/vfs-common/blob/master/include/mgos_vfs.h)",
    "doc": "\n```c\nsize_t mgos_vfs_get_space_total(const char *path);\n```\n> \n> Get FS size of a file system at the specified mountpoint.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_vfs_get_space_free",
    "file": "[mgos_vfs.h](https://github.com/mongoose-os-libs/vfs-common/blob/master/include/mgos_vfs.h)",
    "doc": "\n```c\nsize_t mgos_vfs_get_space_free(const char *path);\n```\n> \n> Get free spece of a file system at the specified mountpoint.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_vfs_gc",
    "file": "[mgos_vfs.h](https://github.com/mongoose-os-libs/vfs-common/blob/master/include/mgos_vfs.h)",
    "doc": "\n```c\nbool mgos_vfs_gc(const char *path);\n```\n> \n> Perform GC of a filesystem at the specified mountpoint.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_vfs_hal_mount",
    "file": "[mgos_vfs.h](https://github.com/mongoose-os-libs/vfs-common/blob/master/include/mgos_vfs.h)",
    "doc": "\n```c\nbool mgos_vfs_hal_mount(const char *path, struct mgos_vfs_fs *fs);\n```\n> \n> Platform implementation must ensure that paths prefixed with \"path\" are\n> routed to \"fs\" and file descriptors are translated appropriately.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_realpath",
    "file": "[mgos_vfs.h](https://github.com/mongoose-os-libs/vfs-common/blob/master/include/mgos_vfs.h)",
    "doc": "\n```c\nchar *mgos_realpath(const char *path, char *resolved_path);\n```\n> \n> Clean up path, see realpath(3).\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_vfs_open",
    "file": "[mgos_vfs.h](https://github.com/mongoose-os-libs/vfs-common/blob/master/include/mgos_vfs.h)",
    "doc": "\n```c\nint mgos_vfs_open(const char *filename, int flags, int mode);\nint mgos_vfs_close(int vfd);\nssize_t mgos_vfs_read(int vfd, void *dst, size_t len);\nssize_t mgos_vfs_write(int vfd, const void *src, size_t len);\nint mgos_vfs_stat(const char *path, struct stat *st);\nint mgos_vfs_fstat(int vfd, struct stat *st);\noff_t mgos_vfs_lseek(int vfd, off_t offset, int whence);\nint mgos_vfs_unlink(const char *path);\nint mgos_vfs_rename(const char *src, const char *dst);\n#if MG_ENABLE_DIRECTORY_LISTING\nDIR *mgos_vfs_opendir(const char *path);\nstruct dirent *mgos_vfs_readdir(DIR *pdir);\nint mgos_vfs_closedir(DIR *pdir);\n#endif\n```\n>  libc API \n",
    "lang": "c"
  },
  {
    "name": "w25xxx_remap_block",
    "file": "[mgos_vfs_dev_w25xxx.h](https://github.com/mongoose-os-libs/vfs-dev-w25xxx/blob/master/include/mgos_vfs_dev_w25xxx.h)",
    "doc": "\n```c\nbool w25xxx_remap_block(struct mgos_vfs_dev *dev, size_t bad_off,\n                        size_t good_off);\n```\n> \n> Adds a bad block lookup table entry.\n> NB: Both offsets are raw, with no bb_reserve correction.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_vfs_fs_lfs_probe",
    "file": "[mgos_vfs_fs_lfs.h](https://github.com/mongoose-os-libs/vfs-fs-lfs/blob/master/include/mgos_vfs_fs_lfs.h)",
    "doc": "\n```c\nbool mgos_vfs_fs_lfs_probe(struct mgos_vfs_dev *dev);\n```\n>  Returns true if the device contains a SPIFFS filesystem. \n",
    "lang": "c"
  },
  {
    "name": "mgos_vfs_fs_spiffs_probe",
    "file": "[mgos_vfs_fs_spiffs.h](https://github.com/mongoose-os-libs/vfs-fs-spiffs/blob/master/include/mgos_vfs_fs_spiffs.h)",
    "doc": "\n```c\nbool mgos_vfs_fs_spiffs_probe(struct mgos_vfs_dev *dev);\n```\n>  Returns true if the device contains a SPIFFS filesystem. \n",
    "lang": "c"
  },
  {
    "name": "mgos_vfs_fs_spiffs_enc_name",
    "file": "[mgos_vfs_fs_spiffs.h](https://github.com/mongoose-os-libs/vfs-fs-spiffs/blob/master/include/mgos_vfs_fs_spiffs.h)",
    "doc": "\n```c\nbool mgos_vfs_fs_spiffs_enc_name(const char *name, char *enc_name,\n                                 size_t enc_name_size);\nbool mgos_vfs_fs_spiffs_dec_name(const char *enc_name, char *name,\n                                 size_t name_size);\n```\n> \n> Name encrypotion/decryption routines.\n> Source and destination can be the same, both must be at least\n> SPIFFS_OBJ_NAME_LEN bytes long. Outputs are guaranteed to be\n> NUL-terminated.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_vfs_fs_spiffs_encrypt_block",
    "file": "[mgos_vfs_fs_spiffs.h](https://github.com/mongoose-os-libs/vfs-fs-spiffs/blob/master/include/mgos_vfs_fs_spiffs.h)",
    "doc": "\n```c\nbool mgos_vfs_fs_spiffs_encrypt_block(spiffs_obj_id obj_id, uint32_t offset,\n                                      void *data, uint32_t len);\nbool mgos_vfs_fs_spiffs_decrypt_block(spiffs_obj_id obj_id, uint32_t offset,\n                                      void *data, uint32_t len);\n#endif\n```\n>  Functions that must be provided by the platform \n",
    "lang": "c"
  },
  {
    "name": "mgos_watson_is_connected",
    "file": "[mgos_watson.h](https://github.com/mongoose-os-libs/watson/blob/master/include/mgos_watson.h)",
    "doc": "\n```c\nbool mgos_watson_is_connected(void);\n```\n>  Returns true if Watson connection is up, false otherwise. \n",
    "lang": "c"
  },
  {
    "name": "mgos_watson_send_event_jsonf",
    "file": "[mgos_watson.h](https://github.com/mongoose-os-libs/watson/blob/master/include/mgos_watson.h)",
    "doc": "\n```c\nbool mgos_watson_send_event_jsonf(const char *event_id, const char *json_fmt,\n                                  ...);\nbool mgos_watson_send_event_jsonp(const struct mg_str *event_id,\n                                  const struct mg_str *body);\n```\n> \n> Send an event, in JSON format.\n> The message should be an object with a \"d\" key and properties, e.g.:\n> `mgos_watson_send_eventf(\"{d: {foo: %d}}\", foo);`\n>  \n",
    "lang": "c"
  },
  {
    "name": "Watson.isConnected()",
    "file": "[api_watson.js](https://github.com/mongoose-os-libs/watson/blob/master/mjs_fs/api_watson.js)",
    "doc": "\n```javascript\nWatson.isConnected()\n```\nReturn value: true if Watson connection is up, false otherwise.\n",
    "lang": "js"
  },
  {
    "name": "mgos_wifi_setup_sta",
    "file": "[mgos_wifi.h](https://github.com/mongoose-os-libs/wifi/blob/master/include/mgos_wifi.h)",
    "doc": "\n```c\nbool mgos_wifi_setup_sta(const struct mgos_config_wifi_sta *cfg);\n```\n> \n> Setup wifi station; `struct mgos_config_wifi_sta` looks as follows:\n> \n> ```c\n> struct mgos_config_wifi_sta {\n>   int enable;\n>   char *ssid;\n>   char *pass;\n>   char *user;\n>   char *anon_identity;\n>   char *cert;\n>   char *key;\n>   char *ca_cert;\n>   char *ip;\n>   char *netmask;\n>   char *gw;\n>   char *nameserver;\n>   char *dhcp_hostname;\n> };\n> ```\n> \n> If `cfg->enable` is true, also calls `mgos_wifi_connect()`.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_wifi_setup_ap",
    "file": "[mgos_wifi.h](https://github.com/mongoose-os-libs/wifi/blob/master/include/mgos_wifi.h)",
    "doc": "\n```c\nbool mgos_wifi_setup_ap(const struct mgos_config_wifi_ap *cfg);\n```\n> \n> Setup wifi access point; `struct mgos_config_wifi_ap` looks as follows:\n> \n> ```c\n> struct mgos_config_wifi_ap {\n>   int enable;\n>   char *ssid;\n>   char *pass;\n>   int hidden;\n>   int channel;\n>   int max_connections;\n>   char *ip;\n>   char *netmask;\n>   char *gw;\n>   char *dhcp_start;\n>   char *dhcp_end;\n>   int trigger_on_gpio;\n>   int disable_after;\n>   int keep_enabled;\n> };\n> ```\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_wifi_setup",
    "file": "[mgos_wifi.h](https://github.com/mongoose-os-libs/wifi/blob/master/include/mgos_wifi.h)",
    "doc": "\n```c\nbool mgos_wifi_setup(struct mgos_config_wifi *cfg);\n```\n> \n> Setup both wifi station and access point at once; `struct mgos_config_wifi`\n> looks as follows:\n> \n> ```c\n> struct mgos_config_wifi {\n>   struct mgos_config_wifi_sta sta; // See definition above\n>   struct mgos_config_wifi_ap ap;   // See definition above\n> };\n> ```\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_wifi_connect",
    "file": "[mgos_wifi.h](https://github.com/mongoose-os-libs/wifi/blob/master/include/mgos_wifi.h)",
    "doc": "\n```c\nbool mgos_wifi_connect(void);\n```\n> \n> Connect to the previously setup wifi station (with `mgos_wifi_setup_sta()`).\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_wifi_disconnect",
    "file": "[mgos_wifi.h](https://github.com/mongoose-os-libs/wifi/blob/master/include/mgos_wifi.h)",
    "doc": "\n```c\nbool mgos_wifi_disconnect(void);\n```\n> \n> Disconnect from wifi station.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_wifi_validate_ap_cfg",
    "file": "[mgos_wifi.h](https://github.com/mongoose-os-libs/wifi/blob/master/include/mgos_wifi.h)",
    "doc": "\n```c\nbool mgos_wifi_validate_ap_cfg(const struct mgos_config_wifi_ap *cfg,\n                               char **msg);\n```\n> \n> Check whether the wifi access point config `cfg` is valid; if it is, `true`\n> is returned; otherwise `false` is returned and error message is written\n> to `*msg`. The caller should free `*msg`.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_wifi_validate_sta_cfg",
    "file": "[mgos_wifi.h](https://github.com/mongoose-os-libs/wifi/blob/master/include/mgos_wifi.h)",
    "doc": "\n```c\nbool mgos_wifi_validate_sta_cfg(const struct mgos_config_wifi_sta *cfg,\n                                char **msg);\n```\n> \n> Check whether the wifi station config `cfg` is valid; if it is, `true` is\n> returned; otherwise `false` is returned and error message is written to\n> `*msg`. The caller should free `*msg`.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_wifi_get_status",
    "file": "[mgos_wifi.h](https://github.com/mongoose-os-libs/wifi/blob/master/include/mgos_wifi.h)",
    "doc": "\n```c\nenum mgos_wifi_status mgos_wifi_get_status(void);\n```\n> \n> Get wifi status, see `enum mgos_wifi_status`.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_wifi_get_status_str",
    "file": "[mgos_wifi.h](https://github.com/mongoose-os-libs/wifi/blob/master/include/mgos_wifi.h)",
    "doc": "\n```c\nchar *mgos_wifi_get_status_str(void);\n```\n> \n> Return wifi status string; the caller should free it.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_wifi_get_connected_ssid",
    "file": "[mgos_wifi.h](https://github.com/mongoose-os-libs/wifi/blob/master/include/mgos_wifi.h)",
    "doc": "\n```c\nchar *mgos_wifi_get_connected_ssid(void);\n```\n> \n> Return wifi ssid the device is currently connected to (if any); the caller\n> should free it. If the device is not connected to any wifi network, `NULL`\n> is returned.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_wifi_get_sta_default_dns",
    "file": "[mgos_wifi.h](https://github.com/mongoose-os-libs/wifi/blob/master/include/mgos_wifi.h)",
    "doc": "\n```c\nchar *mgos_wifi_get_sta_default_dns(void);\n```\n> \n> Return default DNS server IP address. The caller should free it.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_wifi_sta_get_rssi",
    "file": "[mgos_wifi.h](https://github.com/mongoose-os-libs/wifi/blob/master/include/mgos_wifi.h)",
    "doc": "\n```c\nint mgos_wifi_sta_get_rssi(void);\n```\n> \n> Returns RSSI of the station if connected to an AP, otherwise 0.\n> Note: RSSI is a negative number.\n>  \n",
    "lang": "c"
  },
  {
    "name": "(*mgos_wifi_scan_cb_t)",
    "file": "[mgos_wifi.h](https://github.com/mongoose-os-libs/wifi/blob/master/include/mgos_wifi.h)",
    "doc": "\n```c\ntypedef void (*mgos_wifi_scan_cb_t)(int num_res,\n                                    struct mgos_wifi_scan_result *res,\n                                    void *arg);\n```\n> \n> Callback prototype for `mgos_wifi_scan()`, called when wifi scan is done.\n> `num_res` is a number of networks found, `res` is a pointer to the first\n> one. `arg` is an arbitrary pointer given to `mgos_wifi_scan()`.\n> \n> See `mgos_wifi_scan()` for more details.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_wifi_scan",
    "file": "[mgos_wifi.h](https://github.com/mongoose-os-libs/wifi/blob/master/include/mgos_wifi.h)",
    "doc": "\n```c\nvoid mgos_wifi_scan(mgos_wifi_scan_cb_t cb, void *arg);\n```\n> \n> Scan available wifi networks; when the scan is done, the provided callback\n> `cb` will be called with list of SSIDs or NULL on error.\n> \n> Each particular scan result isn't guaranteed to be exhaustive; a few scans\n> might be necessary to get all networks around.\n> \n> Caller owns SSIDS, they are not freed by the callee.\n> \n> A note for implementations: invoking inline is ok.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_wifi_deinit",
    "file": "[mgos_wifi.h](https://github.com/mongoose-os-libs/wifi/blob/master/include/mgos_wifi.h)",
    "doc": "\n```c\nvoid mgos_wifi_deinit(void);\n```\n> \n> Deinitialize wifi.\n>  \n",
    "lang": "c"
  },
  {
    "name": "mgos_wifi_scan_js",
    "file": "[mgos_wifi.h](https://github.com/mongoose-os-libs/wifi/blob/master/include/mgos_wifi.h)",
    "doc": "\n```c\nvoid mgos_wifi_scan_js(struct mjs *mjs);\n#endif\n```\n> \n> Internal: implementation of mJS `Wifi.scan()`; available if only\n> `MGOS_HAVE_MJS` is 1.\n>  \n",
    "lang": "c"
  },
  {
    "name": "Wifi.scan(cb)",
    "file": "[api_wifi.js](https://github.com/mongoose-os-libs/wifi/blob/master/mjs_fs/api_wifi.js)",
    "doc": "\n```javascript\nWifi.scan(cb)\n```\nScan WiFi networks, call `cb` when done.\n`cb` accepts a single argument `results`, which is\neither `undefined` in case of error, or an array of object containing:\n```javascript\n{\n  \"ssid\": \"NetworkName\",\n  \"bssid\": \"12:34:56:78:90:ab\",\n  \"authMode\": Wifi.AUTH_MODE_WPA_PSK, // Auth mode, one of AUTH constants.\n  \"channel\": 11,\n  \"rssi\": -70\n}\n```\nExample:\n```javascript\nWifi.scan(function(results) {\n  print(JSON.stringify(results));\n});\n```\nMust be kept in sync with enum mgos_wifi_auth_mode\n## **Auth modes**\n- `Wifi.AUTH_MODE_OPEN`\n- `Wifi.AUTH_MODE_WEP`\n- `Wifi.AUTH_MODE_WPA_PSK`\n- `Wifi.AUTH_MODE_WPA2_PSK`\n- `Wifi.AUTH_MODE_WPA_WPA2_PSK`\n- `Wifi.AUTH_MODE_WPA2_ENTERPRISE`\n",
    "lang": "js"
  }
]